Merge branch 'main' into pr-1209

tests/agent_test.py

@@ -12,9 +12,11 @@ from crewai.llm import LLM
 from crewai.agents.parser import CrewAgentParser, OutputParserException
 from crewai.tools.tool_calling import InstructorToolCalling
 from crewai.tools.tool_usage import ToolUsage
+from crewai.tools.tool_usage_events import ToolUsageFinished
 from crewai.utilities import RPMController
 from crewai_tools import tool
 from crewai.agents.parser import AgentAction
+from crewai.utilities.events import Emitter
 
 
 def test_agent_llm_creation_with_env_vars():
@@ -178,8 +180,15 @@ def test_agent_execution_with_tools():
         agent=agent,
         expected_output="The result of the multiplication.",
     )
-    output = agent.execute_task(task)
-    assert output == "The result of the multiplication is 12."
+    with patch.object(Emitter, "emit") as emit:
+        output = agent.execute_task(task)
+        assert output == "The result of the multiplication is 12."
+        assert emit.call_count == 1
+        args, _ = emit.call_args
+        assert isinstance(args[1], ToolUsageFinished)
+        assert not args[1].from_cache
+        assert args[1].tool_name == "multiplier"
+        assert args[1].tool_args == {"first_number": 3, "second_number": 4}
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
@@ -267,7 +276,9 @@ def test_cache_hitting():
         "multiplier-{'first_number': 12, 'second_number': 3}": 36,
     }
 
-    with patch.object(CacheHandler, "read") as read:
+    with patch.object(CacheHandler, "read") as read, patch.object(
+        Emitter, "emit"
+    ) as emit:
         read.return_value = "0"
         task = Task(
             description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool, you must use the tool.",
@@ -279,6 +290,10 @@ def test_cache_hitting():
         read.assert_called_with(
             tool="multiplier", input={"first_number": 2, "second_number": 6}
         )
+        assert emit.call_count == 1
+        args, _ = emit.call_args
+        assert isinstance(args[1], ToolUsageFinished)
+        assert args[1].from_cache
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])

tests/cli/deploy/test_deploy_main.py

@@ -1,7 +1,11 @@
-import unittest
-from io import StringIO
-from unittest.mock import MagicMock, patch
+import pytest
+import requests
 import sys
+import unittest
+
+from io import StringIO
+from requests.exceptions import JSONDecodeError
+from unittest.mock import MagicMock, Mock, patch
 
 from crewai.cli.deploy.main import DeployCommand
 from crewai.cli.utils import parse_toml
@@ -33,13 +37,65 @@ class TestDeployCommand(unittest.TestCase):
         with self.assertRaises(SystemExit):
             DeployCommand()
 
-    def test_handle_plus_api_error(self):
+    def test_validate_response_successful_response(self):
+        mock_response = Mock(spec=requests.Response)
+        mock_response.json.return_value = {"message": "Success"}
+        mock_response.status_code = 200
+        mock_response.ok = True
+
         with patch("sys.stdout", new=StringIO()) as fake_out:
-            self.deploy_command._handle_plus_api_error(
-                {"error": "Test error", "message": "Test message"}
+            self.deploy_command._validate_response(mock_response)
+            assert fake_out.getvalue() == ""
+
+    def test_validate_response_json_decode_error(self):
+        mock_response = Mock(spec=requests.Response)
+        mock_response.json.side_effect = JSONDecodeError("Decode error", "", 0)
+        mock_response.status_code = 500
+        mock_response.content = b"Invalid JSON"
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with pytest.raises(SystemExit):
+                self.deploy_command._validate_response(mock_response)
+            output = fake_out.getvalue()
+            assert (
+                "Failed to parse response from Enterprise API failed. Details:"
+                in output
             )
-            self.assertIn("Error: Test error", fake_out.getvalue())
-            self.assertIn("Message: Test message", fake_out.getvalue())
+            assert "Status Code: 500" in output
+            assert "Response:\nb'Invalid JSON'" in output
+
+    def test_validate_response_422_error(self):
+        mock_response = Mock(spec=requests.Response)
+        mock_response.json.return_value = {
+            "field1": ["Error message 1"],
+            "field2": ["Error message 2"],
+        }
+        mock_response.status_code = 422
+        mock_response.ok = False
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with pytest.raises(SystemExit):
+                self.deploy_command._validate_response(mock_response)
+            output = fake_out.getvalue()
+            assert (
+                "Failed to complete operation. Please fix the following errors:"
+                in output
+            )
+            assert "Field1 Error message 1" in output
+            assert "Field2 Error message 2" in output
+
+    def test_validate_response_other_error(self):
+        mock_response = Mock(spec=requests.Response)
+        mock_response.json.return_value = {"error": "Something went wrong"}
+        mock_response.status_code = 500
+        mock_response.ok = False
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with pytest.raises(SystemExit):
+                self.deploy_command._validate_response(mock_response)
+            output = fake_out.getvalue()
+            assert "Request to Enterprise API failed. Details:" in output
+            assert "Details:\nSomething went wrong" in output
 
     def test_standard_no_param_error_message(self):
         with patch("sys.stdout", new=StringIO()) as fake_out:
@@ -87,11 +143,11 @@ class TestDeployCommand(unittest.TestCase):
         mock_display.assert_called_once_with({"uuid": "test-uuid"})
 
     @patch("crewai.cli.deploy.main.fetch_and_json_env_file")
-    @patch("crewai.cli.deploy.main.get_git_remote_url")
+    @patch("crewai.cli.deploy.main.git.Repository.origin_url")
     @patch("builtins.input")
-    def test_create_crew(self, mock_input, mock_get_git_remote_url, mock_fetch_env):
+    def test_create_crew(self, mock_input, mock_git_origin_url, mock_fetch_env):
         mock_fetch_env.return_value = {"ENV_VAR": "value"}
-        mock_get_git_remote_url.return_value = "https://github.com/test/repo.git"
+        mock_git_origin_url.return_value = "https://github.com/test/repo.git"
         mock_input.return_value = ""
 
         mock_response = MagicMock()
@@ -207,30 +263,7 @@ class TestDeployCommand(unittest.TestCase):
         project_name = get_project_name()
         self.assertEqual(project_name, "test_project")
 
-    @patch(
-        "builtins.open",
-        new_callable=unittest.mock.mock_open,
-        read_data="""
-    [[package]]
-    name = "crewai"
-    version = "0.51.1"
-    description = "Some description"
-    category = "main"
-    optional = false
-    python-versions = ">=3.10,<4.0"
-    """,
-    )
-    def test_get_crewai_version(self, mock_open):
+    def test_get_crewai_version(self):
         from crewai.cli.utils import get_crewai_version
 
-        version = get_crewai_version()
-        self.assertEqual(version, "0.51.1")
-
-    @patch("builtins.open", side_effect=FileNotFoundError)
-    def test_get_crewai_version_file_not_found(self, mock_open):
-        from crewai.cli.utils import get_crewai_version
-
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            version = get_crewai_version()
-            self.assertEqual(version, "no-version-found")
-            self.assertIn("Error: poetry.lock not found.", fake_out.getvalue())
+        assert isinstance(get_crewai_version(), str)

tests/cli/test_git.py

@@ -0,0 +1,101 @@
+from crewai.cli.git import Repository
+import pytest
+
+
+@pytest.fixture()
+def repository(fp):
+    fp.register(["git", "--version"], stdout="git version 2.30.0\n")
+    fp.register(["git", "rev-parse", "--is-inside-work-tree"], stdout="true\n")
+    fp.register(["git", "fetch"], stdout="")
+    return Repository(path=".")
+
+
+def test_init_with_invalid_git_repo(fp):
+    fp.register(["git", "--version"], stdout="git version 2.30.0\n")
+    fp.register(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        returncode=1,
+        stderr="fatal: not a git repository\n",
+    )
+
+    with pytest.raises(ValueError):
+        Repository(path="invalid/path")
+
+
+def test_is_git_not_installed(fp):
+    fp.register(["git", "--version"], returncode=1)
+
+    with pytest.raises(
+        ValueError, match="Git is not installed or not found in your PATH."
+    ):
+        Repository(path=".")
+
+
+def test_status(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main [ahead 1]\n",
+    )
+    assert repository.status() == "## main...origin/main [ahead 1]"
+
+
+def test_has_uncommitted_changes(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main\n M somefile.txt\n",
+    )
+    assert repository.has_uncommitted_changes() is True
+
+
+def test_is_ahead_or_behind(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main [ahead 1]\n",
+    )
+    assert repository.is_ahead_or_behind() is True
+
+
+def test_is_synced_when_synced(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n"
+    )
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n"
+    )
+    assert repository.is_synced() is True
+
+
+def test_is_synced_with_uncommitted_changes(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main\n M somefile.txt\n",
+    )
+    assert repository.is_synced() is False
+
+
+def test_is_synced_when_ahead_or_behind(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main [ahead 1]\n",
+    )
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main [ahead 1]\n",
+    )
+    assert repository.is_synced() is False
+
+
+def test_is_synced_with_uncommitted_changes_and_ahead(fp, repository):
+    fp.register(
+        ["git", "status", "--branch", "--porcelain"],
+        stdout="## main...origin/main [ahead 1]\n M somefile.txt\n",
+    )
+    assert repository.is_synced() is False
+
+
+def test_origin_url(fp, repository):
+    fp.register(
+        ["git", "remote", "get-url", "origin"],
+        stdout="https://github.com/user/repo.git\n",
+    )
+    assert repository.origin_url() == "https://github.com/user/repo.git"

tests/cli/test_plus_api.py

@@ -11,15 +11,22 @@ class TestPlusAPI(unittest.TestCase):
 
     def test_init(self):
         self.assertEqual(self.api.api_key, self.api_key)
-        self.assertEqual(
-            self.api.headers,
-            {
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-                "User-Agent": "CrewAI-CLI/no-version-found",
-                "X-Crewai-Version": "no-version-found",
-            },
+        self.assertEqual(self.api.headers["Authorization"], f"Bearer {self.api_key}")
+        self.assertEqual(self.api.headers["Content-Type"], "application/json")
+        self.assertTrue("CrewAI-CLI/" in self.api.headers["User-Agent"])
+        self.assertTrue(self.api.headers["X-Crewai-Version"])
+
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
+    def test_login_to_tool_repository(self, mock_make_request):
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.login_to_tool_repository()
+
+        mock_make_request.assert_called_once_with(
+            "POST", "/crewai_plus/api/v1/tools/login"
         )
+        self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
     def test_get_tool(self, mock_make_request):

tests/cli/test_utils.py

@@ -0,0 +1,100 @@
+import pytest
+import shutil
+import tempfile
+import os
+from crewai.cli import utils
+
+
+@pytest.fixture
+def temp_tree():
+    root_dir = tempfile.mkdtemp()
+
+    create_file(os.path.join(root_dir, "file1.txt"), "Hello, world!")
+    create_file(os.path.join(root_dir, "file2.txt"), "Another file")
+    os.mkdir(os.path.join(root_dir, "empty_dir"))
+    nested_dir = os.path.join(root_dir, "nested_dir")
+    os.mkdir(nested_dir)
+    create_file(os.path.join(nested_dir, "nested_file.txt"), "Nested content")
+
+    yield root_dir
+
+    shutil.rmtree(root_dir)
+
+
+def create_file(path, content):
+    with open(path, "w") as f:
+        f.write(content)
+
+
+def test_tree_find_and_replace_file_content(temp_tree):
+    utils.tree_find_and_replace(temp_tree, "world", "universe")
+    with open(os.path.join(temp_tree, "file1.txt"), "r") as f:
+        assert f.read() == "Hello, universe!"
+
+
+def test_tree_find_and_replace_file_name(temp_tree):
+    old_path = os.path.join(temp_tree, "file2.txt")
+    new_path = os.path.join(temp_tree, "file2_renamed.txt")
+    os.rename(old_path, new_path)
+    utils.tree_find_and_replace(temp_tree, "renamed", "modified")
+    assert os.path.exists(os.path.join(temp_tree, "file2_modified.txt"))
+    assert not os.path.exists(new_path)
+
+
+def test_tree_find_and_replace_directory_name(temp_tree):
+    utils.tree_find_and_replace(temp_tree, "empty", "renamed")
+    assert os.path.exists(os.path.join(temp_tree, "renamed_dir"))
+    assert not os.path.exists(os.path.join(temp_tree, "empty_dir"))
+
+
+def test_tree_find_and_replace_nested_content(temp_tree):
+    utils.tree_find_and_replace(temp_tree, "Nested", "Updated")
+    with open(os.path.join(temp_tree, "nested_dir", "nested_file.txt"), "r") as f:
+        assert f.read() == "Updated content"
+
+
+def test_tree_find_and_replace_no_matches(temp_tree):
+    utils.tree_find_and_replace(temp_tree, "nonexistent", "replacement")
+    assert set(os.listdir(temp_tree)) == {
+        "file1.txt",
+        "file2.txt",
+        "empty_dir",
+        "nested_dir",
+    }
+
+
+def test_tree_copy_full_structure(temp_tree):
+    dest_dir = tempfile.mkdtemp()
+    try:
+        utils.tree_copy(temp_tree, dest_dir)
+        assert set(os.listdir(dest_dir)) == set(os.listdir(temp_tree))
+        assert os.path.isfile(os.path.join(dest_dir, "file1.txt"))
+        assert os.path.isfile(os.path.join(dest_dir, "file2.txt"))
+        assert os.path.isdir(os.path.join(dest_dir, "empty_dir"))
+        assert os.path.isdir(os.path.join(dest_dir, "nested_dir"))
+        assert os.path.isfile(os.path.join(dest_dir, "nested_dir", "nested_file.txt"))
+    finally:
+        shutil.rmtree(dest_dir)
+
+
+def test_tree_copy_preserve_content(temp_tree):
+    dest_dir = tempfile.mkdtemp()
+    try:
+        utils.tree_copy(temp_tree, dest_dir)
+        with open(os.path.join(dest_dir, "file1.txt"), "r") as f:
+            assert f.read() == "Hello, world!"
+        with open(os.path.join(dest_dir, "nested_dir", "nested_file.txt"), "r") as f:
+            assert f.read() == "Nested content"
+    finally:
+        shutil.rmtree(dest_dir)
+
+
+def test_tree_copy_to_existing_directory(temp_tree):
+    dest_dir = tempfile.mkdtemp()
+    try:
+        create_file(os.path.join(dest_dir, "existing_file.txt"), "I was here first")
+        utils.tree_copy(temp_tree, dest_dir)
+        assert os.path.isfile(os.path.join(dest_dir, "existing_file.txt"))
+        assert os.path.isfile(os.path.join(dest_dir, "file1.txt"))
+    finally:
+        shutil.rmtree(dest_dir)

tests/cli/tools/test_main.py

@@ -1,229 +1,344 @@
+import tempfile
 import unittest
 import unittest.mock
+import os
+from contextlib import contextmanager
+
+from pytest import raises
 from crewai.cli.tools.main import ToolCommand
 from io import StringIO
 from unittest.mock import patch, MagicMock
 
+@contextmanager
+def in_temp_dir():
+    original_dir = os.getcwd()
+    with tempfile.TemporaryDirectory() as temp_dir:
+        os.chdir(temp_dir)
+        try:
+            yield temp_dir
+        finally:
+            os.chdir(original_dir)
 
-class TestToolCommand(unittest.TestCase):
-    @patch("crewai.cli.tools.main.subprocess.run")
-    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
-    def test_install_success(self, mock_get, mock_subprocess_run):
-        mock_get_response = MagicMock()
-        mock_get_response.status_code = 200
-        mock_get_response.json.return_value = {
-            "handle": "sample-tool",
-            "repository": {
-                "handle": "sample-repo",
-                "url": "https://example.com/repo",
-                "credentials": "my_very_secret",
-            },
-        }
-        mock_get.return_value = mock_get_response
-        mock_subprocess_run.return_value = MagicMock(stderr=None)
-
+@patch("crewai.cli.tools.main.subprocess.run")
+def test_create_success(mock_subprocess):
+    with in_temp_dir():
         tool_command = ToolCommand()
 
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            tool_command.install("sample-tool")
+        with patch.object(tool_command, "login") as mock_login, patch(
+            "sys.stdout", new=StringIO()
+        ) as fake_out:
+            tool_command.create("test-tool")
             output = fake_out.getvalue()
 
-        mock_get.assert_called_once_with("sample-tool")
-        mock_subprocess_run.assert_any_call(
-            [
-                "poetry",
-                "source",
-                "add",
-                "--priority=explicit",
-                "crewai-sample-repo",
-                "https://example.com/repo",
-            ],
-            text=True,
-            check=True,
-        )
-        mock_subprocess_run.assert_any_call(
-            [
-                "poetry",
-                "config",
-                "http-basic.crewai-sample-repo",
-                "my_very_secret",
-                '""',
-            ],
-            capture_output=False,
-            text=True,
-            check=True,
-        )
-        mock_subprocess_run.assert_any_call(
-            ["poetry", "add", "--source", "crewai-sample-repo", "sample-tool"],
-            capture_output=False,
-            text=True,
-            check=True,
+        assert os.path.isdir("test_tool")
+        assert os.path.isfile(os.path.join("test_tool", "README.md"))
+        assert os.path.isfile(os.path.join("test_tool", "pyproject.toml"))
+        assert os.path.isfile(
+            os.path.join("test_tool", "src", "test_tool", "__init__.py")
         )
+        assert os.path.isfile(os.path.join("test_tool", "src", "test_tool", "tool.py"))
 
-        self.assertIn("Succesfully installed sample-tool", output)
+        with open(
+            os.path.join("test_tool", "src", "test_tool", "tool.py"), "r"
+        ) as f:
+            content = f.read()
+            assert "class TestTool" in content
 
-    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
-    def test_install_tool_not_found(self, mock_get):
-        mock_get_response = MagicMock()
-        mock_get_response.status_code = 404
-        mock_get.return_value = mock_get_response
+        mock_login.assert_called_once()
+        mock_subprocess.assert_called_once_with(["git", "init"], check=True)
 
-        tool_command = ToolCommand()
+        assert "Creating custom tool test_tool..." in output
 
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            with self.assertRaises(SystemExit):
-                tool_command.install("non-existent-tool")
-            output = fake_out.getvalue()
+@patch("crewai.cli.tools.main.subprocess.run")
+@patch("crewai.cli.plus_api.PlusAPI.get_tool")
+def test_install_success(mock_get, mock_subprocess_run):
+    mock_get_response = MagicMock()
+    mock_get_response.status_code = 200
+    mock_get_response.json.return_value = {
+        "handle": "sample-tool",
+        "repository": {"handle": "sample-repo", "url": "https://example.com/repo"},
+    }
+    mock_get.return_value = mock_get_response
+    mock_subprocess_run.return_value = MagicMock(stderr=None)
 
-        mock_get.assert_called_once_with("non-existent-tool")
-        self.assertIn("No tool found with this name", output)
+    tool_command = ToolCommand()
 
-    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
-    def test_install_api_error(self, mock_get):
-        mock_get_response = MagicMock()
-        mock_get_response.status_code = 500
-        mock_get.return_value = mock_get_response
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        tool_command.install("sample-tool")
+        output = fake_out.getvalue()
 
-        tool_command = ToolCommand()
-
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            with self.assertRaises(SystemExit):
-                tool_command.install("error-tool")
-            output = fake_out.getvalue()
-
-        mock_get.assert_called_once_with("error-tool")
-        self.assertIn("Failed to get tool details", output)
-
-    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
-    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
-    @patch(
-        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+    mock_get.assert_called_once_with("sample-tool")
+    mock_subprocess_run.assert_any_call(
+        ["poetry", "add", "--source", "crewai-sample-repo", "sample-tool"],
+        capture_output=False,
+        text=True,
+        check=True,
     )
-    @patch("crewai.cli.tools.main.subprocess.run")
-    @patch(
-        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
-    )
-    @patch(
-        "crewai.cli.tools.main.open",
-        new_callable=unittest.mock.mock_open,
-        read_data=b"sample tarball content",
-    )
-    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-    def test_publish_success(
-        self,
-        mock_publish,
-        mock_open,
-        mock_listdir,
-        mock_subprocess_run,
-        mock_get_project_description,
-        mock_get_project_version,
-        mock_get_project_name,
-    ):
-        mock_publish_response = MagicMock()
-        mock_publish_response.status_code = 200
-        mock_publish_response.json.return_value = {"handle": "sample-tool"}
-        mock_publish.return_value = mock_publish_response
 
+    assert "Succesfully installed sample-tool" in output
+
+@patch("crewai.cli.plus_api.PlusAPI.get_tool")
+def test_install_tool_not_found(mock_get):
+    mock_get_response = MagicMock()
+    mock_get_response.status_code = 404
+    mock_get.return_value = mock_get_response
+
+    tool_command = ToolCommand()
+
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        try:
+            tool_command.install("non-existent-tool")
+        except SystemExit:
+            pass
+        output = fake_out.getvalue()
+
+    mock_get.assert_called_once_with("non-existent-tool")
+    assert "No tool found with this name" in output
+
+@patch("crewai.cli.plus_api.PlusAPI.get_tool")
+def test_install_api_error(mock_get):
+    mock_get_response = MagicMock()
+    mock_get_response.status_code = 500
+    mock_get.return_value = mock_get_response
+
+    tool_command = ToolCommand()
+
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        try:
+            tool_command.install("error-tool")
+        except SystemExit:
+            pass
+        output = fake_out.getvalue()
+
+    mock_get.assert_called_once_with("error-tool")
+    assert "Failed to get tool details" in output
+
+@patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=False)
+def test_publish_when_not_in_sync(mock_is_synced):
+    with patch("sys.stdout", new=StringIO()) as fake_out, \
+         raises(SystemExit):
         tool_command = ToolCommand()
         tool_command.publish(is_public=True)
 
-        mock_get_project_name.assert_called_once_with(require=True)
-        mock_get_project_version.assert_called_once_with(require=True)
-        mock_get_project_description.assert_called_once_with(require=False)
-        mock_subprocess_run.assert_called_once_with(
-            ["poetry", "build", "-f", "sdist", "--output", unittest.mock.ANY],
-            check=True,
-            capture_output=False,
-        )
-        mock_open.assert_called_once_with(unittest.mock.ANY, "rb")
-        mock_publish.assert_called_once_with(
-            handle="sample-tool",
-            is_public=True,
-            version="1.0.0",
-            description="A sample tool",
-            encoded_file=unittest.mock.ANY,
-        )
+    assert "Local changes need to be resolved before publishing" in fake_out.getvalue()
 
-    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
-    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
-    @patch(
-        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+@patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+@patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+@patch("crewai.cli.tools.main.get_project_description", return_value="A sample tool")
+@patch("crewai.cli.tools.main.subprocess.run")
+@patch("crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"])
+@patch(
+    "crewai.cli.tools.main.open",
+    new_callable=unittest.mock.mock_open,
+    read_data=b"sample tarball content",
+)
+@patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+@patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=False)
+def test_publish_when_not_in_sync_and_force(
+    mock_is_synced,
+    mock_publish,
+    mock_open,
+    mock_listdir,
+    mock_subprocess_run,
+    mock_get_project_description,
+    mock_get_project_version,
+    mock_get_project_name,
+):
+    mock_publish_response = MagicMock()
+    mock_publish_response.status_code = 200
+    mock_publish_response.json.return_value = {"handle": "sample-tool"}
+    mock_publish.return_value = mock_publish_response
+
+    tool_command = ToolCommand()
+    tool_command.publish(is_public=True, force=True)
+
+    mock_get_project_name.assert_called_with(require=True)
+    mock_get_project_version.assert_called_with(require=True)
+    mock_get_project_description.assert_called_with(require=False)
+    mock_subprocess_run.assert_called_with(
+        ["poetry", "build", "-f", "sdist", "--output", unittest.mock.ANY],
+        check=True,
+        capture_output=False,
     )
-    @patch("crewai.cli.tools.main.subprocess.run")
-    @patch(
-        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
+    mock_open.assert_called_with(unittest.mock.ANY, "rb")
+    mock_publish.assert_called_with(
+        handle="sample-tool",
+        is_public=True,
+        version="1.0.0",
+        description="A sample tool",
+        encoded_file=unittest.mock.ANY,
     )
-    @patch(
-        "crewai.cli.tools.main.open",
-        new_callable=unittest.mock.mock_open,
-        read_data=b"sample tarball content",
+
+@patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+@patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+@patch("crewai.cli.tools.main.get_project_description", return_value="A sample tool")
+@patch("crewai.cli.tools.main.subprocess.run")
+@patch("crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"])
+@patch(
+    "crewai.cli.tools.main.open",
+    new_callable=unittest.mock.mock_open,
+    read_data=b"sample tarball content",
+)
+@patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+@patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=True)
+def test_publish_success(
+    mock_is_synced,
+    mock_publish,
+    mock_open,
+    mock_listdir,
+    mock_subprocess_run,
+    mock_get_project_description,
+    mock_get_project_version,
+    mock_get_project_name,
+):
+    mock_publish_response = MagicMock()
+    mock_publish_response.status_code = 200
+    mock_publish_response.json.return_value = {"handle": "sample-tool"}
+    mock_publish.return_value = mock_publish_response
+
+    tool_command = ToolCommand()
+    tool_command.publish(is_public=True)
+
+    mock_get_project_name.assert_called_with(require=True)
+    mock_get_project_version.assert_called_with(require=True)
+    mock_get_project_description.assert_called_with(require=False)
+    mock_subprocess_run.assert_called_with(
+        ["poetry", "build", "-f", "sdist", "--output", unittest.mock.ANY],
+        check=True,
+        capture_output=False,
     )
-    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-    def test_publish_failure(
-        self,
-        mock_publish,
-        mock_open,
-        mock_listdir,
-        mock_subprocess_run,
-        mock_get_project_description,
-        mock_get_project_version,
-        mock_get_project_name,
-    ):
-        mock_publish_response = MagicMock()
-        mock_publish_response.status_code = 422
-        mock_publish_response.json.return_value = {"name": ["is already taken"]}
-        mock_publish.return_value = mock_publish_response
-
-        tool_command = ToolCommand()
-
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            with self.assertRaises(SystemExit):
-                tool_command.publish(is_public=True)
-            output = fake_out.getvalue()
-
-        mock_publish.assert_called_once()
-        self.assertIn("Failed to publish tool", output)
-        self.assertIn("Name is already taken", output)
-
-    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
-    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
-    @patch(
-        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+    mock_open.assert_called_with(unittest.mock.ANY, "rb")
+    mock_publish.assert_called_with(
+        handle="sample-tool",
+        is_public=True,
+        version="1.0.0",
+        description="A sample tool",
+        encoded_file=unittest.mock.ANY,
     )
-    @patch("crewai.cli.tools.main.subprocess.run")
-    @patch(
-        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
+
+@patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+@patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+@patch("crewai.cli.tools.main.get_project_description", return_value="A sample tool")
+@patch("crewai.cli.tools.main.subprocess.run")
+@patch("crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"])
+@patch(
+    "crewai.cli.tools.main.open",
+    new_callable=unittest.mock.mock_open,
+    read_data=b"sample tarball content",
+)
+@patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+def test_publish_failure(
+    mock_publish,
+    mock_open,
+    mock_listdir,
+    mock_subprocess_run,
+    mock_get_project_description,
+    mock_get_project_version,
+    mock_get_project_name,
+):
+    mock_publish_response = MagicMock()
+    mock_publish_response.status_code = 422
+    mock_publish_response.json.return_value = {"name": ["is already taken"]}
+    mock_publish.return_value = mock_publish_response
+
+    tool_command = ToolCommand()
+
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        try:
+            tool_command.publish(is_public=True)
+        except SystemExit:
+            pass
+        output = fake_out.getvalue()
+
+    mock_publish.assert_called_once()
+    assert "Failed to complete operation" in output
+    assert "Name is already taken" in output
+
+@patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+@patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+@patch("crewai.cli.tools.main.get_project_description", return_value="A sample tool")
+@patch("crewai.cli.tools.main.subprocess.run")
+@patch("crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"])
+@patch(
+    "crewai.cli.tools.main.open",
+    new_callable=unittest.mock.mock_open,
+    read_data=b"sample tarball content",
+)
+@patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+def test_publish_api_error(
+    mock_publish,
+    mock_open,
+    mock_listdir,
+    mock_subprocess_run,
+    mock_get_project_description,
+    mock_get_project_version,
+    mock_get_project_name,
+):
+    mock_response = MagicMock()
+    mock_response.status_code = 500
+    mock_response.json.return_value = {"error": "Internal Server Error"}
+    mock_response.ok = False
+    mock_publish.return_value = mock_response
+
+    tool_command = ToolCommand()
+
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        try:
+            tool_command.publish(is_public=True)
+        except SystemExit:
+            pass
+        output = fake_out.getvalue()
+
+    mock_publish.assert_called_once()
+    assert "Request to Enterprise API failed" in output
+
+@patch("crewai.cli.plus_api.PlusAPI.login_to_tool_repository")
+@patch("crewai.cli.tools.main.subprocess.run")
+def test_login_success(mock_subprocess_run, mock_login):
+    mock_login_response = MagicMock()
+    mock_login_response.status_code = 200
+    mock_login_response.json.return_value = {
+        "repositories": [
+            {
+                "handle": "tools",
+                "url": "https://example.com/repo",
+            }
+        ],
+        "credential": {"username": "user", "password": "pass"},
+    }
+    mock_login.return_value = mock_login_response
+
+    mock_subprocess_run.return_value = MagicMock(stderr=None)
+
+    tool_command = ToolCommand()
+
+    with patch("sys.stdout", new=StringIO()) as fake_out:
+        tool_command.login()
+        output = fake_out.getvalue()
+
+    mock_login.assert_called_once()
+    mock_subprocess_run.assert_any_call(
+        [
+            "poetry",
+            "source",
+            "add",
+            "--priority=explicit",
+            "crewai-tools",
+            "https://example.com/repo",
+        ],
+        text=True,
+        check=True,
     )
-    @patch(
-        "crewai.cli.tools.main.open",
-        new_callable=unittest.mock.mock_open,
-        read_data=b"sample tarball content",
+    mock_subprocess_run.assert_any_call(
+        [
+            "poetry",
+            "config",
+            "http-basic.crewai-tools",
+            "user",
+            "pass",
+        ],
+        capture_output=False,
+        text=True,
+        check=True,
     )
-    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-    def test_publish_api_error(
-        self,
-        mock_publish,
-        mock_open,
-        mock_listdir,
-        mock_subprocess_run,
-        mock_get_project_description,
-        mock_get_project_version,
-        mock_get_project_name,
-    ):
-        mock_publish_response = MagicMock()
-        mock_publish_response.status_code = 500
-        mock_publish.return_value = mock_publish_response
-
-        tool_command = ToolCommand()
-
-        with patch("sys.stdout", new=StringIO()) as fake_out:
-            with self.assertRaises(SystemExit):
-                tool_command.publish(is_public=True)
-            output = fake_out.getvalue()
-
-        mock_publish.assert_called_once()
-        self.assertIn("Failed to publish tool", output)
-
-
-if __name__ == "__main__":
-    unittest.main()
+    assert "Succesfully authenticated to the tool repository" in output