cornflow 1.1.2__py3-none-any.whl → 1.1.5a1__py3-none-any.whl

cornflow/tests/unit/test_commands.py

@@ -1,3 +1,20 @@
+"""
+Unit tests for Cornflow command functionality.
+
+This module contains tests for various command operations, including:
+
+- User management commands (service, admin, base users)
+- Action registration and management
+- View registration and management
+- Role management
+- Permission assignment and validation
+- DAG deployment and permissions
+- Command argument validation
+
+The tests verify both successful operations and error handling
+for various command scenarios and configurations.
+"""
+
 import json
 
 from flask_testing import TestCase
@@ -37,12 +54,45 @@ from cornflow.tests.integration.test_cornflowclient import load_file
 
 
 class TestCommands(TestCase):
+    """
+    Test suite for Cornflow command functionality.
+
+    This class tests various command operations and their effects on the system:
+
+    - User creation and management commands
+    - Action and view registration
+    - Role initialization and management
+    - Permission system configuration
+    - DAG deployment and permissions
+    - Command argument validation and error handling
+
+    Each test method focuses on a specific command or related set of commands,
+    verifying both successful execution and proper error handling.
+    """
+
     def create_app(self):
+        """
+        Create and configure the Flask application for testing.
+
+        :return: The configured Flask application instance with testing configuration
+        :rtype: Flask
+        """
         app = create_app("testing")
         app.config["OPEN_DEPLOYMENT"] = 1
         return app
 
     def setUp(self):
+        """
+        Set up test environment before each test.
+
+        Initializes:
+
+        - Database tables
+        - Test user credentials
+        - API resources
+        - CLI runner
+        - Base roles
+        """
         db.create_all()
         self.payload = {
             "email": "testemail@test.org",
@@ -53,10 +103,32 @@ class TestCommands(TestCase):
         self.runner.invoke(register_roles, ["-v"])
 
     def tearDown(self):
+        """
+        Clean up test environment after each test.
+
+        Removes database session and drops all tables.
+        """
         db.session.remove()
         db.drop_all()
 
     def user_command(self, command, username, email):
+        """
+        Helper method to test user creation commands.
+
+        :param command: The user creation command to test
+        :type command: function
+        :param username: Username for the new user
+        :type username: str
+        :param email: Email for the new user
+        :type email: str
+        :return: The created user object
+        :rtype: UserModel
+
+        Verifies:
+
+        - User creation success
+        - Correct user attributes
+        """
         self.runner.invoke(
             command,
             ["-u", username, "-e", email, "-p", self.payload["password"], "-v"],
@@ -69,6 +141,18 @@ class TestCommands(TestCase):
         return user
 
     def user_missing_arguments(self, command):
+        """
+        Test user creation with missing required arguments.
+
+        :param command: The user creation command to test
+        :type command: function
+
+        Verifies:
+
+        - Proper error handling for missing username
+        - Proper error handling for missing email
+        - Proper error handling for missing password
+        """
         result = self.runner.invoke(
             command,
             [
@@ -106,9 +190,27 @@ class TestCommands(TestCase):
         self.assertIn("Missing option '-p' / '--password'", result.output)
 
     def test_service_user_command(self):
+        """
+        Test service user creation command.
+
+        Verifies:
+
+        - Successful service user creation
+        - Correct user attributes
+        - Service role assignment
+        """
         return self.user_command(create_service_user, "cornflow", self.payload["email"])
 
     def test_service_user_existing_admin(self):
+        """
+        Test service user creation when admin user exists.
+
+        Verifies:
+
+        - Successful service user creation with existing admin
+        - Correct user attributes
+        - Proper role assignments
+        """
         self.test_admin_user_command()
         self.runner.invoke(
             create_service_user,
@@ -127,22 +229,56 @@ class TestCommands(TestCase):
         self.assertNotEqual(None, user)
         self.assertEqual(self.payload["email"], user.email)
         self.assertEqual("cornflow", user.username)
-        # TODO: check the user has both roles
 
     def test_service_user_existing_service(self):
+        """
+        Test service user creation when service user exists.
+
+        Verifies:
+
+        - Proper handling of existing service user
+        - Correct user attributes
+        - Role consistency
+        """
         self.test_service_user_command()
         user = self.test_service_user_command()
 
         self.assertEqual("cornflow", user.username)
-        # TODO: check the user has the role
 
     def test_admin_user_command(self):
+        """
+        Test admin user creation command.
+
+        Verifies:
+
+        - Successful admin user creation
+        - Correct user attributes
+        - Admin role assignment
+        """
         return self.user_command(create_admin_user, "admin", "admin@test.org")
 
     def test_base_user_command(self):
+        """
+        Test base user creation command.
+
+        Verifies:
+
+        - Successful base user creation
+        - Correct user attributes
+        - Base role assignment
+        """
         return self.user_command(create_base_user, "base", "base@test.org")
 
     def test_register_actions(self):
+        """
+        Test action registration command.
+
+        Verifies:
+
+        - Successful action registration
+        - Correct action names and mappings
+        - Database state after registration
+        """
         self.runner.invoke(register_actions)
 
         actions = ActionModel.query.all()
@@ -151,6 +287,15 @@ class TestCommands(TestCase):
             self.assertEqual(ACTIONS_MAP[a.id], a.name)
 
     def test_register_views(self):
+        """
+        Test view registration command.
+
+        Verifies:
+
+        - Successful view registration
+        - Correct view endpoints
+        - Proper mapping to resources
+        """
         self.runner.invoke(register_views)
 
         views = ViewModel.query.all()
@@ -162,11 +307,29 @@ class TestCommands(TestCase):
         self.assertCountEqual(views_list, resources_list)
 
     def test_register_roles(self):
+        """
+        Test role registration command.
+
+        Verifies:
+
+        - Successful role registration
+        - Correct role names and mappings
+        - Database state after registration
+        """
         roles = RoleModel.query.all()
         for r in roles:
             self.assertEqual(ROLES_MAP[r.id], r.name)
 
     def test_base_permissions_assignation(self):
+        """
+        Test base permission assignment.
+
+        Verifies:
+
+        - Successful permission assignment
+        - Correct role-view-action mappings
+        - Proper access control setup
+        """
         self.runner.invoke(access_init)
 
         for base in BASE_PERMISSION_ASSIGNATION:
@@ -183,12 +346,30 @@ class TestCommands(TestCase):
                     self.assertEqual(True, permission)
 
     def test_deployed_dags_test_command(self):
+        """
+        Test DAG deployment command in test mode.
+
+        Verifies:
+
+        - Successful DAG deployment
+        - Correct DAG registration
+        - Presence of required DAGs
+        """
         register_deployed_dags_command_test(verbose=True)
         dags = DeployedDAG.get_all_objects()
         for dag in ["solve_model_dag", "gc", "timer"]:
             self.assertIn(dag, [d.id for d in dags])
 
     def test_dag_permissions_command(self):
+        """
+        Test DAG permissions command with open deployment.
+
+        Verifies:
+
+        - Successful permission assignment
+        - Correct permissions for service and admin users
+        - Proper access control setup
+        """
         register_deployed_dags_command_test()
         self.test_service_user_command()
         self.test_admin_user_command()
@@ -204,6 +385,15 @@ class TestCommands(TestCase):
         self.assertEqual(3, len(admin_permissions))
 
     def test_dag_permissions_command_no_open(self):
+        """
+        Test DAG permissions command without open deployment.
+
+        Verifies:
+
+        - Successful permission assignment
+        - Restricted access for admin users
+        - Proper service user permissions
+        """
         register_deployed_dags_command_test()
         self.test_service_user_command()
         self.test_admin_user_command()
@@ -219,6 +409,15 @@ class TestCommands(TestCase):
         self.assertEqual(0, len(admin_permissions))
 
     def test_argument_parsing_correct(self):
+        """
+        Test correct argument parsing for DAG permissions.
+
+        Verifies:
+
+        - Proper handling of invalid arguments
+        - Error messages for incorrect input
+        - No permission changes on error
+        """
         self.test_service_user_command()
         result = self.runner.invoke(register_dag_permissions, ["-o", "a"])
 
@@ -230,21 +429,50 @@ class TestCommands(TestCase):
         self.assertEqual(0, len(service_permissions))
 
     def test_argument_parsing_incorrect(self):
+        """
+        Test incorrect argument parsing for DAG permissions.
+
+        Verifies:
+
+        - Error handling for invalid input types
+        - Proper error messages
+        - Command failure behavior
+        """
         self.test_service_user_command()
         result = self.runner.invoke(register_dag_permissions, ["-o", "a"])
         self.assertEqual(2, result.exit_code)
         self.assertIn("is not a valid integer", result.output)
 
     def test_missing_required_argument_service(self):
+        """
+        Test missing arguments for service user creation.
+
+        Verifies proper error handling for missing required arguments.
+        """
         self.user_missing_arguments(create_service_user)
 
     def test_missing_required_argument_admin(self):
+        """
+        Test missing arguments for admin user creation.
+
+        Verifies proper error handling for missing required arguments.
+        """
         self.user_missing_arguments(create_admin_user)
 
     def test_missing_required_argument_user(self):
+        """
+        Test missing arguments for base user creation.
+
+        Verifies proper error handling for missing required arguments.
+        """
         self.user_missing_arguments(create_base_user)
 
     def test_error_no_views(self):
+        """
+        Test error handling when views are not registered.
+
+        Verifies proper error handling when attempting operations without registered views.
+        """
         self.test_service_user_command()
         token = self.client.post(
             LOGIN_URL,

cornflow/tests/unit/test_dags.py

@@ -1,5 +1,17 @@
 """
-Unit test for the DAG endpoints
+Unit tests for the DAG endpoints.
+
+This module contains tests for DAG (Directed Acyclic Graph) functionality, including:
+
+- DAG execution and state management
+- Manual and automated DAG operations
+- Service and planner user permissions
+- DAG deployment and registration
+- Permission cascade deletion
+- DAG configuration and data handling
+
+The tests verify both successful operations and proper error handling
+for various DAG-related scenarios.
 """
 
 # Import from libraries
@@ -31,7 +43,28 @@ from cornflow_client import get_pulp_jsonschema, get_empty_schema
 
 
 class TestDagEndpoint(TestExecutionsDetailEndpointMock):
+    """
+    Test suite for DAG endpoint functionality.
+
+    This class tests the DAG endpoints for different user roles and states:
+
+    - Manual DAG operations for service users
+    - Manual DAG operations for planner users
+    - DAG state management
+    - Data validation and processing
+    """
+
     def test_manual_dag_service_user(self):
+        """
+        Test manual DAG operations for service users.
+
+        Verifies:
+
+        - Service user can create manual DAGs
+        - Proper state assignment
+        - Correct data handling
+        - Required fields validation
+        """
         with open(CASE_PATH) as f:
             payload = json.load(f)
         data = dict(
@@ -59,6 +92,16 @@ class TestDagEndpoint(TestExecutionsDetailEndpointMock):
         )
 
     def test_manual_dag_planner_user(self):
+        """
+        Test manual DAG operations for planner users.
+
+        Verifies:
+
+        - Planner user can create manual DAGs
+        - Proper state assignment
+        - Correct data handling
+        - Required fields validation
+        """
         with open(CASE_PATH) as f:
             payload = json.load(f)
         data = dict(
@@ -87,7 +130,29 @@ class TestDagEndpoint(TestExecutionsDetailEndpointMock):
 
 
 class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
+    """
+    Test suite for DAG detail endpoint functionality.
+
+    This class tests detailed DAG operations including:
+
+    - DAG updates and modifications
+    - Log handling and validation
+    - Data retrieval and verification
+    - Error handling for unauthorized access
+    """
+
     def test_put_dag(self):
+        """
+        Test updating a DAG.
+
+        Verifies:
+
+        - Successful DAG update
+        - Log JSON handling
+        - State transition
+        - Field validation
+        - Log field filtering
+        """
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         with open(CASE_PATH) as f:
             payload = json.load(f)
@@ -104,19 +169,12 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
         data = dict(
             data=payload["data"],
             state=EXEC_STATE_CORRECT,
-            log_json={
-                "time": 10.3,
-                "solver": "dummy",
-                "status": "feasible",
-                "status_code": 2,
-                "sol_code": 1,
-                "some_other_key": "this should be excluded",
-            },
+            log_json=log_json,
         )
         payload_to_check = {**self.payload, **data}
         token = self.create_service_user()
         self.update_row(
-            url=DAG_URL + idx + "/",
+            url=f"{DAG_URL}{idx}/",
             payload_to_check=payload_to_check,
             change=data,
             token=token,
@@ -124,7 +182,7 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
         )
 
         data = self.get_one_row(
-            url=EXECUTION_URL + idx + "/log/",
+            url=f"{EXECUTION_URL}{idx}/log/",
             token=token,
             check_payload=False,
             payload=self.payload,
@@ -137,6 +195,16 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
         self.assertNotIn("some_other_key", data["log"].keys())
 
     def test_get_dag(self):
+        """
+        Test retrieving a DAG.
+
+        Verifies:
+
+        - Successful DAG retrieval
+        - Correct data structure
+        - Instance data consistency
+        - Configuration validation
+        """
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         token = self.create_service_user()
         keys_to_check = ["id", "data", "solution_data", "config"]
@@ -169,6 +237,15 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
         return
 
     def test_get_no_dag(self):
+        """
+        Test retrieving a non-existent DAG.
+
+        Verifies:
+
+        - Proper error handling for missing DAGs
+        - Correct error status code
+        - Error message validation
+        """
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         data = self.get_one_row(
             url=DAG_URL + idx + "/",
@@ -181,11 +258,39 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
 
 
 class TestDeployedDAG(TestCase):
+    """
+    Test suite for deployed DAG functionality.
+
+    This class tests deployed DAG operations including:
+
+    - DAG deployment and registration
+    - Permission management
+    - Cascade deletion
+    - User role interactions
+    """
+
     def create_app(self):
+        """
+        Create and configure the Flask application for testing.
+
+        :return: The configured Flask application instance
+        :rtype: Flask
+        """
         app = create_app("testing")
         return app
 
     def setUp(self):
+        """
+        Set up test environment before each test.
+
+        Initializes:
+
+        - Database tables
+        - Access controls
+        - Test DAGs
+        - Admin user with roles
+        - DAG permissions
+        """
         db.create_all()
         access_init_command(verbose=False)
         register_deployed_dags_command_test(verbose=False)
@@ -226,10 +331,24 @@ class TestDeployedDAG(TestCase):
         register_dag_permissions_command(verbose=False)
 
     def tearDown(self):
+        """
+        Clean up test environment after each test.
+
+        Removes database session and drops all tables.
+        """
         db.session.remove()
         db.drop_all()
 
     def test_permission_cascade_deletion(self):
+        """
+        Test cascade deletion of DAG permissions.
+
+        Verifies:
+
+        - Successful permission deletion on DAG removal
+        - Proper cascade effect
+        - Permission count validation
+        """
         before = PermissionsDAG.get_user_dag_permissions(self.admin["id"])
         self.assertIsNotNone(before)
         dag = DeployedDAG.query.get("solve_model_dag")
@@ -239,6 +358,15 @@ class TestDeployedDAG(TestCase):
         self.assertGreater(len(before), len(after))
 
     def test_get_deployed_dags(self):
+        """
+        Test retrieving deployed DAGs.
+
+        Verifies:
+
+        - Successful DAG listing
+        - Proper authorization
+        - Response structure
+        """
         response = self.client.get(
             DEPLOYED_DAG_URL,
             follow_redirects=True,