andre/crewAI
1
0
Fork 0
mirror of https://github.com/crewAIInc/crewAI.git synced 2026-01-16 11:38:31 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Apply automatic linting fixes to tests directory

Browse Source 
Co-Authored-By: Joe Moura <joao@crewai.com>
This commit is contained in:
Devin AI
2025-05-12 13:31:07 +00:00
parent ad1ea46bbb
commit 46621113af
62 changed files with 1738 additions and 1821 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
tests/cli/authentication/test_auth_main.py
View File

@@ -1,17 +1,18 @@
import unittest
from unittest.mock import MagicMock, patch
import pytest
import requests
from crewai.cli.authentication.main import AuthenticationCommand
class TestAuthenticationCommand(unittest.TestCase):
def setUp(self):
def setUp(self) -> None:
self.auth_command = AuthenticationCommand()
@patch("crewai.cli.authentication.main.requests.post")
def test_get_device_code(self, mock_post):
def test_get_device_code(self, mock_post) -> None:
mock_response = MagicMock()
mock_response.json.return_value = {
"device_code": "123456",
@@ -23,16 +24,14 @@ class TestAuthenticationCommand(unittest.TestCase):
device_code_data = self.auth_command._get_device_code()
self.assertEqual(device_code_data["device_code"], "123456")
self.assertEqual(device_code_data["user_code"], "ABCDEF")
self.assertEqual(
device_code_data["verification_uri_complete"], "https://example.com"
)
self.assertEqual(device_code_data["interval"], 5)
assert device_code_data["device_code"] == "123456"
assert device_code_data["user_code"] == "ABCDEF"
assert device_code_data["verification_uri_complete"] == "https://example.com"
assert device_code_data["interval"] == 5
@patch("crewai.cli.authentication.main.console.print")
@patch("crewai.cli.authentication.main.webbrowser.open")
def test_display_auth_instructions(self, mock_open, mock_print):
def test_display_auth_instructions(self, mock_open, mock_print) -> None:
device_code_data = {
"verification_uri_complete": "https://example.com",
"user_code": "ABCDEF",
@@ -49,8 +48,8 @@ class TestAuthenticationCommand(unittest.TestCase):
@patch("crewai.cli.authentication.main.validate_token")
@patch("crewai.cli.authentication.main.console.print")
def test_poll_for_token_success(
self, mock_print, mock_validate_token, mock_post, mock_tool
):
self, mock_print, mock_validate_token, mock_post, mock_tool,
) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = {
@@ -66,12 +65,12 @@ class TestAuthenticationCommand(unittest.TestCase):
mock_validate_token.assert_called_once_with("TOKEN")
mock_print.assert_called_once_with(
"\n[bold green]Welcome to CrewAI Enterprise![/bold green]\n"
"\n[bold green]Welcome to CrewAI Enterprise![/bold green]\n",
)
@patch("crewai.cli.authentication.main.requests.post")
@patch("crewai.cli.authentication.main.console.print")
def test_poll_for_token_error(self, mock_print, mock_post):
def test_poll_for_token_error(self, mock_print, mock_post) -> None:
mock_response = MagicMock()
mock_response.status_code = 400
mock_response.json.return_value = {
@@ -80,14 +79,14 @@ class TestAuthenticationCommand(unittest.TestCase):
}
mock_post.return_value = mock_response
with self.assertRaises(requests.HTTPError):
with pytest.raises(requests.HTTPError):
self.auth_command._poll_for_token({"device_code": "123456"})
mock_print.assert_not_called()
@patch("crewai.cli.authentication.main.requests.post")
@patch("crewai.cli.authentication.main.console.print")
def test_poll_for_token_timeout(self, mock_print, mock_post):
def test_poll_for_token_timeout(self, mock_print, mock_post) -> None:
mock_response = MagicMock()
mock_response.status_code = 400
mock_response.json.return_value = {
@@ -99,5 +98,5 @@ class TestAuthenticationCommand(unittest.TestCase):
self.auth_command._poll_for_token({"device_code": "123456", "interval": 0.01})
mock_print.assert_called_once_with(
"Timeout: Failed to get the token. Please try again.", style="bold red"
"Timeout: Failed to get the token. Please try again.", style="bold red",
)

40
tests/cli/authentication/test_utils.py
View File

@@ -11,14 +11,14 @@ from crewai.cli.authentication.utils import TokenManager, validate_token
class TestValidateToken(unittest.TestCase):
@patch("crewai.cli.authentication.utils.AsymmetricSignatureVerifier")
@patch("crewai.cli.authentication.utils.TokenVerifier")
def test_validate_token(self, mock_token_verifier, mock_asymmetric_verifier):
def test_validate_token(self, mock_token_verifier, mock_asymmetric_verifier) -> None:
mock_verifier_instance = mock_token_verifier.return_value
mock_id_token = "mock_id_token"
validate_token(mock_id_token)
mock_asymmetric_verifier.assert_called_once_with(
"https://crewai.us.auth0.com/.well-known/jwks.json"
"https://crewai.us.auth0.com/.well-known/jwks.json",
)
mock_token_verifier.assert_called_once_with(
signature_verifier=mock_asymmetric_verifier.return_value,
@@ -29,38 +29,38 @@ class TestValidateToken(unittest.TestCase):
class TestTokenManager(unittest.TestCase):
def setUp(self):
def setUp(self) -> None:
self.token_manager = TokenManager()
@patch("crewai.cli.authentication.utils.TokenManager.read_secure_file")
@patch("crewai.cli.authentication.utils.TokenManager.save_secure_file")
@patch("crewai.cli.authentication.utils.TokenManager._get_or_create_key")
def test_get_or_create_key_existing(self, mock_get_or_create, mock_save, mock_read):
def test_get_or_create_key_existing(self, mock_get_or_create, mock_save, mock_read) -> None:
mock_key = Fernet.generate_key()
mock_get_or_create.return_value = mock_key
token_manager = TokenManager()
result = token_manager.key
self.assertEqual(result, mock_key)
assert result == mock_key
@patch("crewai.cli.authentication.utils.Fernet.generate_key")
@patch("crewai.cli.authentication.utils.TokenManager.read_secure_file")
@patch("crewai.cli.authentication.utils.TokenManager.save_secure_file")
def test_get_or_create_key_new(self, mock_save, mock_read, mock_generate):
def test_get_or_create_key_new(self, mock_save, mock_read, mock_generate) -> None:
mock_key = b"new_key"
mock_read.return_value = None
mock_generate.return_value = mock_key
result = self.token_manager._get_or_create_key()
self.assertEqual(result, mock_key)
assert result == mock_key
mock_read.assert_called_once_with("secret.key")
mock_generate.assert_called_once()
mock_save.assert_called_once_with("secret.key", mock_key)
@patch("crewai.cli.authentication.utils.TokenManager.save_secure_file")
def test_save_tokens(self, mock_save):
def test_save_tokens(self, mock_save) -> None:
access_token = "test_token"
expires_in = 3600
@@ -68,10 +68,10 @@ class TestTokenManager(unittest.TestCase):
mock_save.assert_called_once()
args = mock_save.call_args[0]
self.assertEqual(args[0], "tokens.enc")
assert args[0] == "tokens.enc"
decrypted_data = self.token_manager.fernet.decrypt(args[1])
data = json.loads(decrypted_data)
self.assertEqual(data["access_token"], access_token)
assert data["access_token"] == access_token
expiration = datetime.fromisoformat(data["expiration"])
self.assertAlmostEqual(
expiration,
@@ -80,7 +80,7 @@ class TestTokenManager(unittest.TestCase):
)
@patch("crewai.cli.authentication.utils.TokenManager.read_secure_file")
def test_get_token_valid(self, mock_read):
def test_get_token_valid(self, mock_read) -> None:
access_token = "test_token"
expiration = (datetime.now() + timedelta(hours=1)).isoformat()
data = {"access_token": access_token, "expiration": expiration}
@@ -89,10 +89,10 @@ class TestTokenManager(unittest.TestCase):
result = self.token_manager.get_token()
self.assertEqual(result, access_token)
assert result == access_token
@patch("crewai.cli.authentication.utils.TokenManager.read_secure_file")
def test_get_token_expired(self, mock_read):
def test_get_token_expired(self, mock_read) -> None:
access_token = "test_token"
expiration = (datetime.now() - timedelta(hours=1)).isoformat()
data = {"access_token": access_token, "expiration": expiration}
@@ -101,12 +101,12 @@ class TestTokenManager(unittest.TestCase):
result = self.token_manager.get_token()
self.assertIsNone(result)
assert result is None
@patch("crewai.cli.authentication.utils.TokenManager.get_secure_storage_path")
@patch("builtins.open", new_callable=unittest.mock.mock_open)
@patch("crewai.cli.authentication.utils.os.chmod")
def test_save_secure_file(self, mock_chmod, mock_open, mock_get_path):
def test_save_secure_file(self, mock_chmod, mock_open, mock_get_path) -> None:
mock_path = MagicMock()
mock_get_path.return_value = mock_path
filename = "test_file.txt"
@@ -121,9 +121,9 @@ class TestTokenManager(unittest.TestCase):
@patch("crewai.cli.authentication.utils.TokenManager.get_secure_storage_path")
@patch(
"builtins.open", new_callable=unittest.mock.mock_open, read_data=b"test_content"
"builtins.open", new_callable=unittest.mock.mock_open, read_data=b"test_content",
)
def test_read_secure_file_exists(self, mock_open, mock_get_path):
def test_read_secure_file_exists(self, mock_open, mock_get_path) -> None:
mock_path = MagicMock()
mock_get_path.return_value = mock_path
mock_path.__truediv__.return_value.exists.return_value = True
@@ -131,12 +131,12 @@ class TestTokenManager(unittest.TestCase):
result = self.token_manager.read_secure_file(filename)
self.assertEqual(result, b"test_content")
assert result == b"test_content"
mock_path.__truediv__.assert_called_once_with(filename)
mock_open.assert_called_once_with(mock_path.__truediv__.return_value, "rb")
@patch("crewai.cli.authentication.utils.TokenManager.get_secure_storage_path")
def test_read_secure_file_not_exists(self, mock_get_path):
def test_read_secure_file_not_exists(self, mock_get_path) -> None:
mock_path = MagicMock()
mock_get_path.return_value = mock_path
mock_path.__truediv__.return_value.exists.return_value = False
@@ -144,5 +144,5 @@ class TestTokenManager(unittest.TestCase):
result = self.token_manager.read_secure_file(filename)
self.assertIsNone(result)
assert result is None
mock_path.__truediv__.assert_called_once_with(filename)

71
tests/cli/cli_test.py
View File

@@ -27,7 +27,7 @@ def runner():
@mock.patch("crewai.cli.cli.train_crew")
def test_train_default_iterations(train_crew, runner):
def test_train_default_iterations(train_crew, runner) -> None:
result = runner.invoke(train)
train_crew.assert_called_once_with(5, "trained_agents_data.pkl")
@@ -36,7 +36,7 @@ def test_train_default_iterations(train_crew, runner):
@mock.patch("crewai.cli.cli.train_crew")
def test_train_custom_iterations(train_crew, runner):
def test_train_custom_iterations(train_crew, runner) -> None:
result = runner.invoke(train, ["--n_iterations", "10"])
train_crew.assert_called_once_with(10, "trained_agents_data.pkl")
@@ -45,7 +45,7 @@ def test_train_custom_iterations(train_crew, runner):
@mock.patch("crewai.cli.cli.train_crew")
def test_train_invalid_string_iterations(train_crew, runner):
def test_train_invalid_string_iterations(train_crew, runner) -> None:
result = runner.invoke(train, ["--n_iterations", "invalid"])
train_crew.assert_not_called()
@@ -66,12 +66,12 @@ def mock_crew():
@pytest.fixture
def mock_get_crews(mock_crew):
with mock.patch(
"crewai.cli.reset_memories_command.get_crews", return_value=[mock_crew]
"crewai.cli.reset_memories_command.get_crews", return_value=[mock_crew],
) as mock_get_crew:
yield mock_get_crew
def test_reset_all_memories(mock_get_crews, runner):
def test_reset_all_memories(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-a"])
call_count = 0
@@ -86,7 +86,7 @@ def test_reset_all_memories(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_short_term_memories(mock_get_crews, runner):
def test_reset_short_term_memories(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-s"])
call_count = 0
for crew in mock_get_crews.return_value:
@@ -99,7 +99,7 @@ def test_reset_short_term_memories(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_entity_memories(mock_get_crews, runner):
def test_reset_entity_memories(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-e"])
call_count = 0
for crew in mock_get_crews.return_value:
@@ -110,7 +110,7 @@ def test_reset_entity_memories(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_long_term_memories(mock_get_crews, runner):
def test_reset_long_term_memories(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-l"])
call_count = 0
for crew in mock_get_crews.return_value:
@@ -121,7 +121,7 @@ def test_reset_long_term_memories(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_kickoff_outputs(mock_get_crews, runner):
def test_reset_kickoff_outputs(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-k"])
call_count = 0
for crew in mock_get_crews.return_value:
@@ -135,12 +135,12 @@ def test_reset_kickoff_outputs(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_multiple_memory_flags(mock_get_crews, runner):
def test_reset_multiple_memory_flags(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["-s", "-l"])
call_count = 0
for crew in mock_get_crews.return_value:
crew.reset_memories.assert_has_calls(
[mock.call(command_type="long"), mock.call(command_type="short")]
[mock.call(command_type="long"), mock.call(command_type="short")],
)
assert (
f"[Crew ({crew.name})] Long term memory has been reset.\n"
@@ -151,7 +151,7 @@ def test_reset_multiple_memory_flags(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_knowledge(mock_get_crews, runner):
def test_reset_knowledge(mock_get_crews, runner) -> None:
result = runner.invoke(reset_memories, ["--knowledge"])
call_count = 0
for crew in mock_get_crews.return_value:
@@ -162,7 +162,7 @@ def test_reset_knowledge(mock_get_crews, runner):
assert call_count == 1, "reset_memories should have been called once"
def test_reset_memory_from_many_crews(mock_get_crews, runner):
def test_reset_memory_from_many_crews(mock_get_crews, runner) -> None:
crews = []
for crew_id in ["id-1234", "id-5678"]:
@@ -185,7 +185,7 @@ def test_reset_memory_from_many_crews(mock_get_crews, runner):
assert call_count == 2, "reset_memories should have been called twice"
def test_reset_no_memory_flags(runner):
def test_reset_no_memory_flags(runner) -> None:
result = runner.invoke(
reset_memories,
)
@@ -195,21 +195,21 @@ def test_reset_no_memory_flags(runner):
)
def test_version_flag(runner):
def test_version_flag(runner) -> None:
result = runner.invoke(version)
assert result.exit_code == 0
assert "crewai version:" in result.output
def test_version_command(runner):
def test_version_command(runner) -> None:
result = runner.invoke(version)
assert result.exit_code == 0
assert "crewai version:" in result.output
def test_version_command_with_tools(runner):
def test_version_command_with_tools(runner) -> None:
result = runner.invoke(version, ["--tools"])
assert result.exit_code == 0
@@ -221,7 +221,7 @@ def test_version_command_with_tools(runner):
@mock.patch("crewai.cli.cli.evaluate_crew")
def test_test_default_iterations(evaluate_crew, runner):
def test_test_default_iterations(evaluate_crew, runner) -> None:
result = runner.invoke(test)
evaluate_crew.assert_called_once_with(3, "gpt-4o-mini")
@@ -230,7 +230,7 @@ def test_test_default_iterations(evaluate_crew, runner):
@mock.patch("crewai.cli.cli.evaluate_crew")
def test_test_custom_iterations(evaluate_crew, runner):
def test_test_custom_iterations(evaluate_crew, runner) -> None:
result = runner.invoke(test, ["--n_iterations", "5", "--model", "gpt-4o"])
evaluate_crew.assert_called_once_with(5, "gpt-4o")
@@ -239,7 +239,7 @@ def test_test_custom_iterations(evaluate_crew, runner):
@mock.patch("crewai.cli.cli.evaluate_crew")
def test_test_invalid_string_iterations(evaluate_crew, runner):
def test_test_invalid_string_iterations(evaluate_crew, runner) -> None:
result = runner.invoke(test, ["--n_iterations", "invalid"])
evaluate_crew.assert_not_called()
@@ -251,7 +251,7 @@ def test_test_invalid_string_iterations(evaluate_crew, runner):
@mock.patch("crewai.cli.cli.AuthenticationCommand")
def test_signup(command, runner):
def test_signup(command, runner) -> None:
mock_auth = command.return_value
result = runner.invoke(signup)
@@ -260,7 +260,7 @@ def test_signup(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_create(command, runner):
def test_deploy_create(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deploy_create)
@@ -269,7 +269,7 @@ def test_deploy_create(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_list(command, runner):
def test_deploy_list(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deploy_list)
@@ -278,7 +278,7 @@ def test_deploy_list(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_push(command, runner):
def test_deploy_push(command, runner) -> None:
mock_deploy = command.return_value
uuid = "test-uuid"
result = runner.invoke(deploy_push, ["-u", uuid])
@@ -288,7 +288,7 @@ def test_deploy_push(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_push_no_uuid(command, runner):
def test_deploy_push_no_uuid(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deploy_push)
@@ -297,7 +297,7 @@ def test_deploy_push_no_uuid(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_status(command, runner):
def test_deploy_status(command, runner) -> None:
mock_deploy = command.return_value
uuid = "test-uuid"
result = runner.invoke(deply_status, ["-u", uuid])
@@ -307,7 +307,7 @@ def test_deploy_status(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_status_no_uuid(command, runner):
def test_deploy_status_no_uuid(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deply_status)
@@ -316,7 +316,7 @@ def test_deploy_status_no_uuid(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_logs(command, runner):
def test_deploy_logs(command, runner) -> None:
mock_deploy = command.return_value
uuid = "test-uuid"
result = runner.invoke(deploy_logs, ["-u", uuid])
@@ -326,7 +326,7 @@ def test_deploy_logs(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_logs_no_uuid(command, runner):
def test_deploy_logs_no_uuid(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deploy_logs)
@@ -335,7 +335,7 @@ def test_deploy_logs_no_uuid(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_remove(command, runner):
def test_deploy_remove(command, runner) -> None:
mock_deploy = command.return_value
uuid = "test-uuid"
result = runner.invoke(deploy_remove, ["-u", uuid])
@@ -345,7 +345,7 @@ def test_deploy_remove(command, runner):
@mock.patch("crewai.cli.cli.DeployCommand")
def test_deploy_remove_no_uuid(command, runner):
def test_deploy_remove_no_uuid(command, runner) -> None:
mock_deploy = command.return_value
result = runner.invoke(deploy_remove)
@@ -355,12 +355,11 @@ def test_deploy_remove_no_uuid(command, runner):
@mock.patch("crewai.cli.add_crew_to_flow.create_embedded_crew")
@mock.patch("pathlib.Path.exists", return_value=True) # Mock the existence check
def test_flow_add_crew(mock_path_exists, mock_create_embedded_crew, runner):
def test_flow_add_crew(mock_path_exists, mock_create_embedded_crew, runner) -> None:
crew_name = "new_crew"
result = runner.invoke(flow_add_crew, [crew_name])
# Log the output for debugging
print(result.output)
assert result.exit_code == 0, f"Command failed with output: {result.output}"
assert f"Adding crew {crew_name} to the flow" in result.output
@@ -373,11 +372,11 @@ def test_flow_add_crew(mock_path_exists, mock_create_embedded_crew, runner):
assert isinstance(call_kwargs["parent_folder"], Path)
def test_add_crew_to_flow_not_in_root(runner):
def test_add_crew_to_flow_not_in_root(runner) -> None:
# Simulate not being in the root of a flow project
with mock.patch("pathlib.Path.exists", autospec=True) as mock_exists:
# Mock Path.exists to return False when checking for pyproject.toml
def exists_side_effect(self):
def exists_side_effect(self) -> bool:
if self.name == "pyproject.toml":
return False # Simulate that pyproject.toml does not exist
return True # All other paths exist
@@ -388,5 +387,5 @@ def test_add_crew_to_flow_not_in_root(runner):
assert result.exit_code != 0
assert "This command must be run from the root of a flow project." in str(
result.output
result.output,
)

56
tests/cli/config_test.py
View File

@@ -8,34 +8,34 @@ from crewai.cli.config import Settings
class TestSettings(unittest.TestCase):
def setUp(self):
def setUp(self) -> None:
self.test_dir = Path(tempfile.mkdtemp())
self.config_path = self.test_dir / "settings.json"
def tearDown(self):
def tearDown(self) -> None:
shutil.rmtree(self.test_dir)
def test_empty_initialization(self):
def test_empty_initialization(self) -> None:
settings = Settings(config_path=self.config_path)
self.assertIsNone(settings.tool_repository_username)
self.assertIsNone(settings.tool_repository_password)
assert settings.tool_repository_username is None
assert settings.tool_repository_password is None
def test_initialization_with_data(self):
def test_initialization_with_data(self) -> None:
settings = Settings(
config_path=self.config_path, tool_repository_username="user1"
config_path=self.config_path, tool_repository_username="user1",
)
self.assertEqual(settings.tool_repository_username, "user1")
self.assertIsNone(settings.tool_repository_password)
assert settings.tool_repository_username == "user1"
assert settings.tool_repository_password is None
def test_initialization_with_existing_file(self):
def test_initialization_with_existing_file(self) -> None:
self.config_path.parent.mkdir(parents=True, exist_ok=True)
with self.config_path.open("w") as f:
json.dump({"tool_repository_username": "file_user"}, f)
settings = Settings(config_path=self.config_path)
self.assertEqual(settings.tool_repository_username, "file_user")
assert settings.tool_repository_username == "file_user"
def test_merge_file_and_input_data(self):
def test_merge_file_and_input_data(self) -> None:
self.config_path.parent.mkdir(parents=True, exist_ok=True)
with self.config_path.open("w") as f:
json.dump(
@@ -47,61 +47,61 @@ class TestSettings(unittest.TestCase):
)
settings = Settings(
config_path=self.config_path, tool_repository_username="new_user"
config_path=self.config_path, tool_repository_username="new_user",
)
self.assertEqual(settings.tool_repository_username, "new_user")
self.assertEqual(settings.tool_repository_password, "file_pass")
assert settings.tool_repository_username == "new_user"
assert settings.tool_repository_password == "file_pass"
def test_dump_new_settings(self):
def test_dump_new_settings(self) -> None:
settings = Settings(
config_path=self.config_path, tool_repository_username="user1"
config_path=self.config_path, tool_repository_username="user1",
)
settings.dump()
with self.config_path.open("r") as f:
saved_data = json.load(f)
self.assertEqual(saved_data["tool_repository_username"], "user1")
assert saved_data["tool_repository_username"] == "user1"
def test_update_existing_settings(self):
def test_update_existing_settings(self) -> None:
self.config_path.parent.mkdir(parents=True, exist_ok=True)
with self.config_path.open("w") as f:
json.dump({"existing_setting": "value"}, f)
settings = Settings(
config_path=self.config_path, tool_repository_username="user1"
config_path=self.config_path, tool_repository_username="user1",
)
settings.dump()
with self.config_path.open("r") as f:
saved_data = json.load(f)
self.assertEqual(saved_data["existing_setting"], "value")
self.assertEqual(saved_data["tool_repository_username"], "user1")
assert saved_data["existing_setting"] == "value"
assert saved_data["tool_repository_username"] == "user1"
def test_none_values(self):
def test_none_values(self) -> None:
settings = Settings(config_path=self.config_path, tool_repository_username=None)
settings.dump()
with self.config_path.open("r") as f:
saved_data = json.load(f)
self.assertIsNone(saved_data.get("tool_repository_username"))
assert saved_data.get("tool_repository_username") is None
def test_invalid_json_in_config(self):
def test_invalid_json_in_config(self) -> None:
self.config_path.parent.mkdir(parents=True, exist_ok=True)
with self.config_path.open("w") as f:
f.write("invalid json")
try:
settings = Settings(config_path=self.config_path)
self.assertIsNone(settings.tool_repository_username)
assert settings.tool_repository_username is None
except json.JSONDecodeError:
self.fail("Settings initialization should handle invalid JSON")
def test_empty_config_file(self):
def test_empty_config_file(self) -> None:
self.config_path.parent.mkdir(parents=True, exist_ok=True)
self.config_path.touch()
settings = Settings(config_path=self.config_path)
self.assertIsNone(settings.tool_repository_username)
assert settings.tool_repository_username is None

87
tests/cli/deploy/test_deploy_main.py
View File

@@ -15,7 +15,7 @@ class TestDeployCommand(unittest.TestCase):
@patch("crewai.cli.command.get_auth_token")
@patch("crewai.cli.deploy.main.get_project_name")
@patch("crewai.cli.command.PlusAPI")
def setUp(self, mock_plus_api, mock_get_project_name, mock_get_auth_token):
def setUp(self, mock_plus_api, mock_get_project_name, mock_get_auth_token) -> None:
self.mock_get_auth_token = mock_get_auth_token
self.mock_get_project_name = mock_get_project_name
self.mock_plus_api = mock_plus_api
@@ -26,18 +26,18 @@ class TestDeployCommand(unittest.TestCase):
self.deploy_command = DeployCommand()
self.mock_client = self.deploy_command.plus_api_client
def test_init_success(self):
self.assertEqual(self.deploy_command.project_name, "test_project")
def test_init_success(self) -> None:
assert self.deploy_command.project_name == "test_project"
self.mock_plus_api.assert_called_once_with(api_key="test_token")
@patch("crewai.cli.command.get_auth_token")
def test_init_failure(self, mock_get_auth_token):
def test_init_failure(self, mock_get_auth_token) -> None:
mock_get_auth_token.side_effect = Exception("Auth failed")
with self.assertRaises(SystemExit):
with pytest.raises(SystemExit):
DeployCommand()
def test_validate_response_successful_response(self):
def test_validate_response_successful_response(self) -> None:
mock_response = Mock(spec=requests.Response)
mock_response.json.return_value = {"message": "Success"}
mock_response.status_code = 200
@@ -47,7 +47,7 @@ class TestDeployCommand(unittest.TestCase):
self.deploy_command._validate_response(mock_response)
assert fake_out.getvalue() == ""
def test_validate_response_json_decode_error(self):
def test_validate_response_json_decode_error(self) -> None:
mock_response = Mock(spec=requests.Response)
mock_response.json.side_effect = JSONDecodeError("Decode error", "", 0)
mock_response.status_code = 500
@@ -64,7 +64,7 @@ class TestDeployCommand(unittest.TestCase):
assert "Status Code: 500" in output
assert "Response:\nb'Invalid JSON'" in output
def test_validate_response_422_error(self):
def test_validate_response_422_error(self) -> None:
mock_response = Mock(spec=requests.Response)
mock_response.json.return_value = {
"field1": ["Error message 1"],
@@ -84,7 +84,7 @@ class TestDeployCommand(unittest.TestCase):
assert "Field1 Error message 1" in output
assert "Field2 Error message 2" in output
def test_validate_response_other_error(self):
def test_validate_response_other_error(self) -> None:
mock_response = Mock(spec=requests.Response)
mock_response.json.return_value = {"error": "Something went wrong"}
mock_response.status_code = 500
@@ -97,29 +97,29 @@ class TestDeployCommand(unittest.TestCase):
assert "Request to Enterprise API failed. Details:" in output
assert "Details:\nSomething went wrong" in output
def test_standard_no_param_error_message(self):
def test_standard_no_param_error_message(self) -> None:
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command._standard_no_param_error_message()
self.assertIn("No UUID provided", fake_out.getvalue())
assert "No UUID provided" in fake_out.getvalue()
def test_display_deployment_info(self):
def test_display_deployment_info(self) -> None:
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command._display_deployment_info(
{"uuid": "test-uuid", "status": "deployed"}
{"uuid": "test-uuid", "status": "deployed"},
)
self.assertIn("Deploying the crew...", fake_out.getvalue())
self.assertIn("test-uuid", fake_out.getvalue())
self.assertIn("deployed", fake_out.getvalue())
assert "Deploying the crew..." in fake_out.getvalue()
assert "test-uuid" in fake_out.getvalue()
assert "deployed" in fake_out.getvalue()
def test_display_logs(self):
def test_display_logs(self) -> None:
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command._display_logs(
[{"timestamp": "2023-01-01", "level": "INFO", "message": "Test log"}]
[{"timestamp": "2023-01-01", "level": "INFO", "message": "Test log"}],
)
self.assertIn("2023-01-01 - INFO: Test log", fake_out.getvalue())
assert "2023-01-01 - INFO: Test log" in fake_out.getvalue()
@patch("crewai.cli.deploy.main.DeployCommand._display_deployment_info")
def test_deploy_with_uuid(self, mock_display):
def test_deploy_with_uuid(self, mock_display) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = {"uuid": "test-uuid"}
@@ -131,7 +131,7 @@ class TestDeployCommand(unittest.TestCase):
mock_display.assert_called_once_with({"uuid": "test-uuid"})
@patch("crewai.cli.deploy.main.DeployCommand._display_deployment_info")
def test_deploy_with_project_name(self, mock_display):
def test_deploy_with_project_name(self, mock_display) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = {"uuid": "test-uuid"}
@@ -145,7 +145,7 @@ class TestDeployCommand(unittest.TestCase):
@patch("crewai.cli.deploy.main.fetch_and_json_env_file")
@patch("crewai.cli.deploy.main.git.Repository.origin_url")
@patch("builtins.input")
def test_create_crew(self, mock_input, mock_git_origin_url, mock_fetch_env):
def test_create_crew(self, mock_input, mock_git_origin_url, mock_fetch_env) -> None:
mock_fetch_env.return_value = {"ENV_VAR": "value"}
mock_git_origin_url.return_value = "https://github.com/test/repo.git"
mock_input.return_value = ""
@@ -157,10 +157,10 @@ class TestDeployCommand(unittest.TestCase):
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command.create_crew()
self.assertIn("Deployment created successfully!", fake_out.getvalue())
self.assertIn("new-uuid", fake_out.getvalue())
assert "Deployment created successfully!" in fake_out.getvalue()
assert "new-uuid" in fake_out.getvalue()
def test_list_crews(self):
def test_list_crews(self) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = [
@@ -171,10 +171,10 @@ class TestDeployCommand(unittest.TestCase):
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command.list_crews()
self.assertIn("Crew1 (uuid1) active", fake_out.getvalue())
self.assertIn("Crew2 (uuid2) inactive", fake_out.getvalue())
assert "Crew1 (uuid1) active" in fake_out.getvalue()
assert "Crew2 (uuid2) inactive" in fake_out.getvalue()
def test_get_crew_status(self):
def test_get_crew_status(self) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = {"name": "InternalCrew", "status": "active"}
@@ -182,10 +182,10 @@ class TestDeployCommand(unittest.TestCase):
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command.get_crew_status()
self.assertIn("InternalCrew", fake_out.getvalue())
self.assertIn("active", fake_out.getvalue())
assert "InternalCrew" in fake_out.getvalue()
assert "active" in fake_out.getvalue()
def test_get_crew_logs(self):
def test_get_crew_logs(self) -> None:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = [
@@ -196,22 +196,20 @@ class TestDeployCommand(unittest.TestCase):
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command.get_crew_logs(None)
self.assertIn("2023-01-01 - INFO: Log1", fake_out.getvalue())
self.assertIn("2023-01-02 - ERROR: Log2", fake_out.getvalue())
assert "2023-01-01 - INFO: Log1" in fake_out.getvalue()
assert "2023-01-02 - ERROR: Log2" in fake_out.getvalue()
def test_remove_crew(self):
def test_remove_crew(self) -> None:
mock_response = MagicMock()
mock_response.status_code = 204
self.mock_client.delete_crew_by_name.return_value = mock_response
with patch("sys.stdout", new=StringIO()) as fake_out:
self.deploy_command.remove_crew(None)
self.assertIn(
"Crew 'test_project' removed successfully", fake_out.getvalue()
)
assert "Crew 'test_project' removed successfully" in fake_out.getvalue()
@unittest.skipIf(sys.version_info < (3, 11), "Requires Python 3.11+")
def test_parse_toml_python_311_plus(self):
def test_parse_toml_python_311_plus(self) -> None:
toml_content = """
[tool.poetry]
name = "test_project"
@@ -222,7 +220,7 @@ class TestDeployCommand(unittest.TestCase):
crewai = { extras = ["tools"], version = ">=0.51.0,<1.0.0" }
"""
parsed = parse_toml(toml_content)
self.assertEqual(parsed["tool"]["poetry"]["name"], "test_project")
assert parsed["tool"]["poetry"]["name"] == "test_project"
@patch(
"builtins.open",
@@ -235,12 +233,11 @@ class TestDeployCommand(unittest.TestCase):
dependencies = ["crewai"]
""",
)
def test_get_project_name_python_310(self, mock_open):
def test_get_project_name_python_310(self, mock_open) -> None:
from crewai.cli.utils import get_project_name
project_name = get_project_name()
print("project_name", project_name)
self.assertEqual(project_name, "test_project")
assert project_name == "test_project"
@unittest.skipIf(sys.version_info < (3, 11), "Requires Python 3.11+")
@patch(
@@ -254,13 +251,13 @@ class TestDeployCommand(unittest.TestCase):
dependencies = ["crewai"]
""",
)
def test_get_project_name_python_311_plus(self, mock_open):
def test_get_project_name_python_311_plus(self, mock_open) -> None:
from crewai.cli.utils import get_project_name
project_name = get_project_name()
self.assertEqual(project_name, "test_project")
assert project_name == "test_project"
def test_get_crewai_version(self):
def test_get_crewai_version(self) -> None:
from crewai.cli.version import get_crewai_version
assert isinstance(get_crewai_version(), str)

7
tests/cli/test_constants.py
View File

@@ -1,14 +1,13 @@
import pytest
from crewai.cli.constants import ENV_VARS, MODELS, PROVIDERS
def test_huggingface_in_providers():
def test_huggingface_in_providers() -> None:
"""Test that Huggingface is in the PROVIDERS list."""
assert "huggingface" in PROVIDERS
def test_huggingface_env_vars():
def test_huggingface_env_vars() -> None:
"""Test that Huggingface environment variables are properly configured."""
assert "huggingface" in ENV_VARS
assert any(
@@ -17,7 +16,7 @@ def test_huggingface_env_vars():
)
def test_huggingface_models():
def test_huggingface_models() -> None:
"""Test that Huggingface models are properly configured."""
assert "huggingface" in MODELS
assert len(MODELS["huggingface"]) > 0

18
tests/cli/test_crew_test.py
View File

@@ -7,7 +7,7 @@ from crewai.cli import evaluate_crew
@pytest.mark.parametrize(
"n_iterations,model",
("n_iterations", "model"),
[
(1, "gpt-4o"),
(5, "gpt-3.5-turbo"),
@@ -15,10 +15,10 @@ from crewai.cli import evaluate_crew
],
)
@mock.patch("crewai.cli.evaluate_crew.subprocess.run")
def test_crew_success(mock_subprocess_run, n_iterations, model):
def test_crew_success(mock_subprocess_run, n_iterations, model) -> None:
"""Test the crew function for successful execution."""
mock_subprocess_run.return_value = subprocess.CompletedProcess(
args=f"uv run test {n_iterations} {model}", returncode=0
args=f"uv run test {n_iterations} {model}", returncode=0,
)
result = evaluate_crew.evaluate_crew(n_iterations, model)
@@ -32,7 +32,7 @@ def test_crew_success(mock_subprocess_run, n_iterations, model):
@mock.patch("crewai.cli.evaluate_crew.click")
def test_test_crew_zero_iterations(click):
def test_test_crew_zero_iterations(click) -> None:
evaluate_crew.evaluate_crew(0, "gpt-4o")
click.echo.assert_called_once_with(
"An unexpected error occurred: The number of iterations must be a positive integer.",
@@ -41,7 +41,7 @@ def test_test_crew_zero_iterations(click):
@mock.patch("crewai.cli.evaluate_crew.click")
def test_test_crew_negative_iterations(click):
def test_test_crew_negative_iterations(click) -> None:
evaluate_crew.evaluate_crew(-2, "gpt-4o")
click.echo.assert_called_once_with(
"An unexpected error occurred: The number of iterations must be a positive integer.",
@@ -51,7 +51,7 @@ def test_test_crew_negative_iterations(click):
@mock.patch("crewai.cli.evaluate_crew.click")
@mock.patch("crewai.cli.evaluate_crew.subprocess.run")
def test_test_crew_called_process_error(mock_subprocess_run, click):
def test_test_crew_called_process_error(mock_subprocess_run, click) -> None:
n_iterations = 5
mock_subprocess_run.side_effect = subprocess.CalledProcessError(
returncode=1,
@@ -74,13 +74,13 @@ def test_test_crew_called_process_error(mock_subprocess_run, click):
err=True,
),
mock.call.echo("Error", err=True),
]
],
)
@mock.patch("crewai.cli.evaluate_crew.click")
@mock.patch("crewai.cli.evaluate_crew.subprocess.run")
def test_test_crew_unexpected_exception(mock_subprocess_run, click):
def test_test_crew_unexpected_exception(mock_subprocess_run, click) -> None:
# Arrange
n_iterations = 5
mock_subprocess_run.side_effect = Exception("Unexpected error")
@@ -93,5 +93,5 @@ def test_test_crew_unexpected_exception(mock_subprocess_run, click):
check=True,
)
click.echo.assert_called_once_with(
"An unexpected error occurred: Unexpected error", err=True
"An unexpected error occurred: Unexpected error", err=True,
)

28
tests/cli/test_git.py
View File

@@ -3,7 +3,7 @@ import pytest
from crewai.cli.git import Repository
@pytest.fixture()
@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")
@@ -11,7 +11,7 @@ def repository(fp):
return Repository(path=".")
def test_init_with_invalid_git_repo(fp):
def test_init_with_invalid_git_repo(fp) -> None:
fp.register(["git", "--version"], stdout="git version 2.30.0\n")
fp.register(
["git", "rev-parse", "--is-inside-work-tree"],
@@ -23,16 +23,16 @@ def test_init_with_invalid_git_repo(fp):
Repository(path="invalid/path")
def test_is_git_not_installed(fp):
def test_is_git_not_installed(fp) -> None:
fp.register(["git", "--version"], returncode=1)
with pytest.raises(
ValueError, match="Git is not installed or not found in your PATH."
ValueError, match="Git is not installed or not found in your PATH.",
):
Repository(path=".")
def test_status(fp, repository):
def test_status(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main [ahead 1]\n",
@@ -40,7 +40,7 @@ def test_status(fp, repository):
assert repository.status() == "## main...origin/main [ahead 1]"
def test_has_uncommitted_changes(fp, repository):
def test_has_uncommitted_changes(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main\n M somefile.txt\n",
@@ -48,7 +48,7 @@ def test_has_uncommitted_changes(fp, repository):
assert repository.has_uncommitted_changes() is True
def test_is_ahead_or_behind(fp, repository):
def test_is_ahead_or_behind(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main [ahead 1]\n",
@@ -56,17 +56,17 @@ def test_is_ahead_or_behind(fp, repository):
assert repository.is_ahead_or_behind() is True
def test_is_synced_when_synced(fp, repository):
def test_is_synced_when_synced(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n"
["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n",
)
fp.register(
["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n"
["git", "status", "--branch", "--porcelain"], stdout="## main...origin/main\n",
)
assert repository.is_synced() is True
def test_is_synced_with_uncommitted_changes(fp, repository):
def test_is_synced_with_uncommitted_changes(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main\n M somefile.txt\n",
@@ -74,7 +74,7 @@ def test_is_synced_with_uncommitted_changes(fp, repository):
assert repository.is_synced() is False
def test_is_synced_when_ahead_or_behind(fp, repository):
def test_is_synced_when_ahead_or_behind(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main [ahead 1]\n",
@@ -86,7 +86,7 @@ def test_is_synced_when_ahead_or_behind(fp, repository):
assert repository.is_synced() is False
def test_is_synced_with_uncommitted_changes_and_ahead(fp, repository):
def test_is_synced_with_uncommitted_changes_and_ahead(fp, repository) -> None:
fp.register(
["git", "status", "--branch", "--porcelain"],
stdout="## main...origin/main [ahead 1]\n M somefile.txt\n",
@@ -94,7 +94,7 @@ def test_is_synced_with_uncommitted_changes_and_ahead(fp, repository):
assert repository.is_synced() is False
def test_origin_url(fp, repository):
def test_origin_url(fp, repository) -> None:
fp.register(
["git", "remote", "get-url", "origin"],
stdout="https://github.com/user/repo.git\n",

97
tests/cli/test_plus_api.py
View File

@@ -6,43 +6,43 @@ from crewai.cli.plus_api import PlusAPI
class TestPlusAPI(unittest.TestCase):
def setUp(self):
def setUp(self) -> None:
self.api_key = "test_api_key"
self.api = PlusAPI(self.api_key)
def test_init(self):
self.assertEqual(self.api.api_key, self.api_key)
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"])
def test_init(self) -> None:
assert self.api.api_key == self.api_key
assert self.api.headers["Authorization"] == f"Bearer {self.api_key}"
assert self.api.headers["Content-Type"] == "application/json"
assert "CrewAI-CLI/" in self.api.headers["User-Agent"]
assert self.api.headers["X-Crewai-Version"]
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_login_to_tool_repository(self, mock_make_request):
def test_login_to_tool_repository(self, mock_make_request) -> None:
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"
"POST", "/crewai_plus/api/v1/tools/login",
)
self.assertEqual(response, mock_response)
assert response == mock_response
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_get_tool(self, mock_make_request):
def test_get_tool(self, mock_make_request) -> None:
mock_response = MagicMock()
mock_make_request.return_value = mock_response
response = self.api.get_tool("test_tool_handle")
mock_make_request.assert_called_once_with(
"GET", "/crewai_plus/api/v1/tools/test_tool_handle"
"GET", "/crewai_plus/api/v1/tools/test_tool_handle",
)
self.assertEqual(response, mock_response)
assert response == mock_response
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_publish_tool(self, mock_make_request):
def test_publish_tool(self, mock_make_request) -> None:
mock_response = MagicMock()
mock_make_request.return_value = mock_response
handle = "test_tool_handle"
@@ -52,7 +52,7 @@ class TestPlusAPI(unittest.TestCase):
encoded_file = "encoded_test_file"
response = self.api.publish_tool(
handle, public, version, description, encoded_file
handle, public, version, description, encoded_file,
)
params = {
@@ -63,12 +63,12 @@ class TestPlusAPI(unittest.TestCase):
"description": description,
}
mock_make_request.assert_called_once_with(
"POST", "/crewai_plus/api/v1/tools", json=params
"POST", "/crewai_plus/api/v1/tools", json=params,
)
self.assertEqual(response, mock_response)
assert response == mock_response
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_publish_tool_without_description(self, mock_make_request):
def test_publish_tool_without_description(self, mock_make_request) -> None:
mock_response = MagicMock()
mock_make_request.return_value = mock_response
handle = "test_tool_handle"
@@ -78,7 +78,7 @@ class TestPlusAPI(unittest.TestCase):
encoded_file = "encoded_test_file"
response = self.api.publish_tool(
handle, public, version, description, encoded_file
handle, public, version, description, encoded_file,
)
params = {
@@ -89,12 +89,12 @@ class TestPlusAPI(unittest.TestCase):
"description": description,
}
mock_make_request.assert_called_once_with(
"POST", "/crewai_plus/api/v1/tools", json=params
"POST", "/crewai_plus/api/v1/tools", json=params,
)
self.assertEqual(response, mock_response)
assert response == mock_response
@patch("crewai.cli.plus_api.requests.Session")
def test_make_request(self, mock_session):
def test_make_request(self, mock_session) -> None:
mock_response = MagicMock()
mock_session_instance = mock_session.return_value
@@ -104,94 +104,91 @@ class TestPlusAPI(unittest.TestCase):
mock_session.assert_called_once()
mock_session_instance.request.assert_called_once_with(
"GET", f"{self.api.base_url}/test_endpoint", headers=self.api.headers
"GET", f"{self.api.base_url}/test_endpoint", headers=self.api.headers,
)
mock_session_instance.trust_env = False
self.assertEqual(response, mock_response)
assert response == mock_response
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_deploy_by_name(self, mock_make_request):
def test_deploy_by_name(self, mock_make_request) -> None:
self.api.deploy_by_name("test_project")
mock_make_request.assert_called_once_with(
"POST", "/crewai_plus/api/v1/crews/by-name/test_project/deploy"
"POST", "/crewai_plus/api/v1/crews/by-name/test_project/deploy",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_deploy_by_uuid(self, mock_make_request):
def test_deploy_by_uuid(self, mock_make_request) -> None:
self.api.deploy_by_uuid("test_uuid")
mock_make_request.assert_called_once_with(
"POST", "/crewai_plus/api/v1/crews/test_uuid/deploy"
"POST", "/crewai_plus/api/v1/crews/test_uuid/deploy",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_crew_status_by_name(self, mock_make_request):
def test_crew_status_by_name(self, mock_make_request) -> None:
self.api.crew_status_by_name("test_project")
mock_make_request.assert_called_once_with(
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/status"
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/status",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_crew_status_by_uuid(self, mock_make_request):
def test_crew_status_by_uuid(self, mock_make_request) -> None:
self.api.crew_status_by_uuid("test_uuid")
mock_make_request.assert_called_once_with(
"GET", "/crewai_plus/api/v1/crews/test_uuid/status"
"GET", "/crewai_plus/api/v1/crews/test_uuid/status",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_crew_by_name(self, mock_make_request):
def test_crew_by_name(self, mock_make_request) -> None:
self.api.crew_by_name("test_project")
mock_make_request.assert_called_once_with(
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/deployment"
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/deployment",
)
self.api.crew_by_name("test_project", "custom_log")
mock_make_request.assert_called_with(
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/custom_log"
"GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/custom_log",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_crew_by_uuid(self, mock_make_request):
def test_crew_by_uuid(self, mock_make_request) -> None:
self.api.crew_by_uuid("test_uuid")
mock_make_request.assert_called_once_with(
"GET", "/crewai_plus/api/v1/crews/test_uuid/logs/deployment"
"GET", "/crewai_plus/api/v1/crews/test_uuid/logs/deployment",
)
self.api.crew_by_uuid("test_uuid", "custom_log")
mock_make_request.assert_called_with(
"GET", "/crewai_plus/api/v1/crews/test_uuid/logs/custom_log"
"GET", "/crewai_plus/api/v1/crews/test_uuid/logs/custom_log",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_delete_crew_by_name(self, mock_make_request):
def test_delete_crew_by_name(self, mock_make_request) -> None:
self.api.delete_crew_by_name("test_project")
mock_make_request.assert_called_once_with(
"DELETE", "/crewai_plus/api/v1/crews/by-name/test_project"
"DELETE", "/crewai_plus/api/v1/crews/by-name/test_project",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_delete_crew_by_uuid(self, mock_make_request):
def test_delete_crew_by_uuid(self, mock_make_request) -> None:
self.api.delete_crew_by_uuid("test_uuid")
mock_make_request.assert_called_once_with(
"DELETE", "/crewai_plus/api/v1/crews/test_uuid"
"DELETE", "/crewai_plus/api/v1/crews/test_uuid",
)
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_list_crews(self, mock_make_request):
def test_list_crews(self, mock_make_request) -> None:
self.api.list_crews()
mock_make_request.assert_called_once_with("GET", "/crewai_plus/api/v1/crews")
@patch("crewai.cli.plus_api.PlusAPI._make_request")
def test_create_crew(self, mock_make_request):
def test_create_crew(self, mock_make_request) -> None:
payload = {"name": "test_crew"}
self.api.create_crew(payload)
mock_make_request.assert_called_once_with(
"POST", "/crewai_plus/api/v1/crews", json=payload
"POST", "/crewai_plus/api/v1/crews", json=payload,
)
@patch.dict(os.environ, {"CREWAI_BASE_URL": "https://custom-url.com/api"})
def test_custom_base_url(self):
def test_custom_base_url(self) -> None:
custom_api = PlusAPI("test_key")
self.assertEqual(
custom_api.base_url,
"https://custom-url.com/api",
)
assert custom_api.base_url == "https://custom-url.com/api"

26
tests/cli/test_utils.py
View File

@@ -23,18 +23,18 @@ def temp_tree():
shutil.rmtree(root_dir)
def create_file(path, content):
def create_file(path, content) -> None:
with open(path, "w") as f:
f.write(content)
def test_tree_find_and_replace_file_content(temp_tree):
def test_tree_find_and_replace_file_content(temp_tree) -> None:
utils.tree_find_and_replace(temp_tree, "world", "universe")
with open(os.path.join(temp_tree, "file1.txt"), "r") as f:
with open(os.path.join(temp_tree, "file1.txt")) as f:
assert f.read() == "Hello, universe!"
def test_tree_find_and_replace_file_name(temp_tree):
def test_tree_find_and_replace_file_name(temp_tree) -> None:
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)
@@ -43,19 +43,19 @@ def test_tree_find_and_replace_file_name(temp_tree):
assert not os.path.exists(new_path)
def test_tree_find_and_replace_directory_name(temp_tree):
def test_tree_find_and_replace_directory_name(temp_tree) -> None:
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):
def test_tree_find_and_replace_nested_content(temp_tree) -> None:
utils.tree_find_and_replace(temp_tree, "Nested", "Updated")
with open(os.path.join(temp_tree, "nested_dir", "nested_file.txt"), "r") as f:
with open(os.path.join(temp_tree, "nested_dir", "nested_file.txt")) as f:
assert f.read() == "Updated content"
def test_tree_find_and_replace_no_matches(temp_tree):
def test_tree_find_and_replace_no_matches(temp_tree) -> None:
utils.tree_find_and_replace(temp_tree, "nonexistent", "replacement")
assert set(os.listdir(temp_tree)) == {
"file1.txt",
@@ -65,7 +65,7 @@ def test_tree_find_and_replace_no_matches(temp_tree):
}
def test_tree_copy_full_structure(temp_tree):
def test_tree_copy_full_structure(temp_tree) -> None:
dest_dir = tempfile.mkdtemp()
try:
utils.tree_copy(temp_tree, dest_dir)
@@ -79,19 +79,19 @@ def test_tree_copy_full_structure(temp_tree):
shutil.rmtree(dest_dir)
def test_tree_copy_preserve_content(temp_tree):
def test_tree_copy_preserve_content(temp_tree) -> None:
dest_dir = tempfile.mkdtemp()
try:
utils.tree_copy(temp_tree, dest_dir)
with open(os.path.join(dest_dir, "file1.txt"), "r") as f:
with open(os.path.join(dest_dir, "file1.txt")) as f:
assert f.read() == "Hello, world!"
with open(os.path.join(dest_dir, "nested_dir", "nested_file.txt"), "r") as f:
with open(os.path.join(dest_dir, "nested_dir", "nested_file.txt")) as f:
assert f.read() == "Nested content"
finally:
shutil.rmtree(dest_dir)
def test_tree_copy_to_existing_directory(temp_tree):
def test_tree_copy_to_existing_directory(temp_tree) -> None:
dest_dir = tempfile.mkdtemp()
try:
create_file(os.path.join(dest_dir, "existing_file.txt"), "I was here first")

22
tests/cli/tools/test_main.py
View File

@@ -33,7 +33,7 @@ def tool_command():
@patch("crewai.cli.tools.main.subprocess.run")
def test_create_success(mock_subprocess, capsys, tool_command):
def test_create_success(mock_subprocess, capsys, tool_command) -> None:
with in_temp_dir():
tool_command.create("test-tool")
output = capsys.readouterr().out
@@ -43,11 +43,11 @@ def test_create_success(mock_subprocess, capsys, tool_command):
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")
os.path.join("test_tool", "src", "test_tool", "__init__.py"),
)
assert os.path.isfile(os.path.join("test_tool", "src", "test_tool", "tool.py"))
with open(os.path.join("test_tool", "src", "test_tool", "tool.py"), "r") as f:
with open(os.path.join("test_tool", "src", "test_tool", "tool.py")) as f:
content = f.read()
assert "class TestTool" in content
@@ -56,7 +56,7 @@ def test_create_success(mock_subprocess, capsys, tool_command):
@patch("crewai.cli.tools.main.subprocess.run")
@patch("crewai.cli.plus_api.PlusAPI.get_tool")
def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command):
def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command) -> None:
mock_get_response = MagicMock()
mock_get_response.status_code = 200
mock_get_response.json.return_value = {
@@ -87,7 +87,7 @@ def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command):
@patch("crewai.cli.plus_api.PlusAPI.get_tool")
def test_install_tool_not_found(mock_get, capsys, tool_command):
def test_install_tool_not_found(mock_get, capsys, tool_command) -> None:
mock_get_response = MagicMock()
mock_get_response.status_code = 404
mock_get.return_value = mock_get_response
@@ -101,7 +101,7 @@ def test_install_tool_not_found(mock_get, capsys, tool_command):
@patch("crewai.cli.plus_api.PlusAPI.get_tool")
def test_install_api_error(mock_get, capsys, tool_command):
def test_install_api_error(mock_get, capsys, tool_command) -> None:
mock_get_response = MagicMock()
mock_get_response.status_code = 500
mock_get.return_value = mock_get_response
@@ -115,7 +115,7 @@ def test_install_api_error(mock_get, capsys, tool_command):
@patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=False)
def test_publish_when_not_in_sync(mock_is_synced, capsys, tool_command):
def test_publish_when_not_in_sync(mock_is_synced, capsys, tool_command) -> None:
with raises(SystemExit):
tool_command.publish(is_public=True)
@@ -145,7 +145,7 @@ def test_publish_when_not_in_sync_and_force(
mock_get_project_version,
mock_get_project_name,
tool_command,
):
) -> None:
mock_publish_response = MagicMock()
mock_publish_response.status_code = 200
mock_publish_response.json.return_value = {"handle": "sample-tool"}
@@ -193,7 +193,7 @@ def test_publish_success(
mock_get_project_version,
mock_get_project_name,
tool_command,
):
) -> None:
mock_publish_response = MagicMock()
mock_publish_response.status_code = 200
mock_publish_response.json.return_value = {"handle": "sample-tool"}
@@ -240,7 +240,7 @@ def test_publish_failure(
mock_get_project_name,
capsys,
tool_command,
):
) -> None:
mock_publish_response = MagicMock()
mock_publish_response.status_code = 422
mock_publish_response.json.return_value = {"name": ["is already taken"]}
@@ -276,7 +276,7 @@ def test_publish_api_error(
mock_get_project_name,
capsys,
tool_command,
):
) -> None:
mock_response = MagicMock()
mock_response.status_code = 500
mock_response.json.return_value = {"error": "Internal Server Error"}

14
tests/cli/train_crew_test.py
View File

@@ -5,7 +5,7 @@ from crewai.cli.train_crew import train_crew
@mock.patch("crewai.cli.train_crew.subprocess.run")
def test_train_crew_positive_iterations(mock_subprocess_run):
def test_train_crew_positive_iterations(mock_subprocess_run) -> None:
n_iterations = 5
mock_subprocess_run.return_value = subprocess.CompletedProcess(
args=["uv", "run", "train", str(n_iterations)],
@@ -25,7 +25,7 @@ def test_train_crew_positive_iterations(mock_subprocess_run):
@mock.patch("crewai.cli.train_crew.click")
def test_train_crew_zero_iterations(click):
def test_train_crew_zero_iterations(click) -> None:
train_crew(0, "trained_agents_data.pkl")
click.echo.assert_called_once_with(
"An unexpected error occurred: The number of iterations must be a positive integer.",
@@ -34,7 +34,7 @@ def test_train_crew_zero_iterations(click):
@mock.patch("crewai.cli.train_crew.click")
def test_train_crew_negative_iterations(click):
def test_train_crew_negative_iterations(click) -> None:
train_crew(-2, "trained_agents_data.pkl")
click.echo.assert_called_once_with(
"An unexpected error occurred: The number of iterations must be a positive integer.",
@@ -44,7 +44,7 @@ def test_train_crew_negative_iterations(click):
@mock.patch("crewai.cli.train_crew.click")
@mock.patch("crewai.cli.train_crew.subprocess.run")
def test_train_crew_called_process_error(mock_subprocess_run, click):
def test_train_crew_called_process_error(mock_subprocess_run, click) -> None:
n_iterations = 5
mock_subprocess_run.side_effect = subprocess.CalledProcessError(
returncode=1,
@@ -67,13 +67,13 @@ def test_train_crew_called_process_error(mock_subprocess_run, click):
err=True,
),
mock.call.echo("Error", err=True),
]
],
)
@mock.patch("crewai.cli.train_crew.click")
@mock.patch("crewai.cli.train_crew.subprocess.run")
def test_train_crew_unexpected_exception(mock_subprocess_run, click):
def test_train_crew_unexpected_exception(mock_subprocess_run, click) -> None:
n_iterations = 5
mock_subprocess_run.side_effect = Exception("Unexpected error")
train_crew(n_iterations, "trained_agents_data.pkl")
@@ -85,5 +85,5 @@ def test_train_crew_unexpected_exception(mock_subprocess_run, click):
check=True,
)
click.echo.assert_called_once_with(
"An unexpected error occurred: Unexpected error", err=True
"An unexpected error occurred: Unexpected error", err=True,
)