cornflow 1.2.3a5__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

cornflow/tests/unit/test_get_resources.py

@@ -0,0 +1,103 @@
+"""
+Unit tests for the get_resources function
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+from flask import Flask
+from cornflow.endpoints import get_resources, resources
+from cornflow.shared.const import CONDITIONAL_ENDPOINTS
+
+
+class TestGetResources(unittest.TestCase):
+    """Test the get_resources function"""
+
+    def setUp(self):
+        self.app = Flask(__name__)
+        self.mock_signup_view = MagicMock()
+        self.mock_signup_view.view_class = MagicMock()
+        self.mock_login_view = MagicMock()
+        self.mock_login_view.view_class = MagicMock()
+
+    def test_returns_base_resources_when_no_conditional_endpoints(self):
+        """Test that get_resources returns base resources when no conditional endpoints are registered"""
+        with self.app.app_context():
+            with patch("flask.current_app.view_functions", {}):
+                result = get_resources()
+                self.assertEqual(result, resources)
+
+    def test_adds_conditional_endpoint_when_registered(self):
+        """Test that get_resources adds conditional endpoints when they are registered"""
+        with self.app.app_context():
+            mock_view_functions = {"signup": self.mock_signup_view}
+
+            with patch("flask.current_app.view_functions", mock_view_functions):
+                result = get_resources()
+
+                # Should have one more resource than base
+                self.assertEqual(len(result), len(resources) + 1)
+
+                # Check that signup endpoint was added correctly
+                signup_resource = next(
+                    (r for r in result if r["endpoint"] == "signup"), None
+                )
+                self.assertIsNotNone(signup_resource)
+                self.assertEqual(
+                    signup_resource["urls"], CONDITIONAL_ENDPOINTS["signup"]
+                )
+                self.assertEqual(
+                    signup_resource["resource"], self.mock_signup_view.view_class
+                )
+
+    def test_adds_both_signup_and_login_when_registered(self):
+        """Test that get_resources adds both signup and login when both are registered"""
+        with self.app.app_context():
+            mock_view_functions = {
+                "signup": self.mock_signup_view,
+                "login": self.mock_login_view,
+            }
+
+            with patch("flask.current_app.view_functions", mock_view_functions):
+                result = get_resources()
+
+                # Should have two more resources than base
+                self.assertEqual(len(result), len(resources) + 2)
+
+                # Check that both endpoints were added correctly
+                signup_resource = next(
+                    (r for r in result if r["endpoint"] == "signup"), None
+                )
+                login_resource = next(
+                    (r for r in result if r["endpoint"] == "login"), None
+                )
+
+                self.assertIsNotNone(signup_resource)
+                self.assertIsNotNone(login_resource)
+                self.assertEqual(
+                    signup_resource["urls"], CONDITIONAL_ENDPOINTS["signup"]
+                )
+                self.assertEqual(login_resource["urls"], CONDITIONAL_ENDPOINTS["login"])
+
+    def test_does_not_add_duplicate_endpoints(self):
+        """Test that get_resources does not add endpoints that already exist in base resources"""
+        with self.app.app_context():
+            mock_view_functions = {
+                "instance": MagicMock()
+            }  # 'instance' already exists in base resources
+
+            with patch("flask.current_app.view_functions", mock_view_functions):
+                result = get_resources()
+                self.assertEqual(len(result), len(resources))
+
+    def test_ignores_non_conditional_endpoints(self):
+        """Test that get_resources ignores endpoints that are not in CONDITIONAL_ENDPOINTS"""
+        with self.app.app_context():
+            mock_view_functions = {"non_conditional_endpoint": MagicMock()}
+
+            with patch("flask.current_app.view_functions", mock_view_functions):
+                result = get_resources()
+                self.assertEqual(len(result), len(resources))
+
+
+if __name__ == "__main__":
+    unittest.main()

cornflow/tests/unit/test_health.py

@@ -1,10 +1,18 @@
 import os
+from unittest.mock import patch, MagicMock
 
 from cornflow.shared import db
 
 from cornflow.app import create_app
 from cornflow.commands import access_init_command
-from cornflow.shared.const import STATUS_HEALTHY, CORNFLOW_VERSION
+from cornflow.shared.const import (
+    STATUS_HEALTHY,
+    STATUS_UNHEALTHY,
+    CORNFLOW_VERSION,
+    DATABRICKS_BACKEND,
+    AIRFLOW_BACKEND,
+)
+from cornflow.shared.exceptions import EndpointNotImplemented
 from cornflow.tests.const import HEALTH_URL
 from cornflow.tests.custom_test_case import CustomTestCase
 
@@ -28,10 +36,83 @@ class TestHealth(CustomTestCase):
         response = self.client.get(HEALTH_URL)
         self.assertEqual(200, response.status_code)
         cf_status = response.json["cornflow_status"]
-        af_status = response.json["airflow_status"]
+        backend_status = response.json["backend_status"]
         cf_version = response.json["cornflow_version"]
         expected_version = CORNFLOW_VERSION
         self.assertEqual(str, type(cf_status))
-        self.assertEqual(str, type(af_status))
+        self.assertEqual(str, type(backend_status))
         self.assertEqual(cf_status, STATUS_HEALTHY)
         self.assertEqual(cf_version, expected_version)
+
+    @patch("cornflow.endpoints.health.Databricks")
+    def test_health_databricks_backend_healthy(self, mock_databricks):
+        """Test health endpoint with Databricks backend when service is healthy"""
+        self.create_service_user()
+        os.environ["CORNFLOW_SERVICE_USER"] = "testuser4"
+
+        # Mock Databricks client
+        mock_db_client = MagicMock()
+        mock_db_client.is_alive.return_value = True
+        mock_databricks.from_config.return_value = mock_db_client
+
+        # Set Databricks backend
+        with self.app.app_context():
+            self.app.config["CORNFLOW_BACKEND"] = DATABRICKS_BACKEND
+
+            response = self.client.get(HEALTH_URL)
+
+            self.assertEqual(200, response.status_code)
+            cf_status = response.json["cornflow_status"]
+            backend_status = response.json["backend_status"]
+            cf_version = response.json["cornflow_version"]
+
+            self.assertEqual(cf_status, STATUS_HEALTHY)
+            self.assertEqual(backend_status, STATUS_HEALTHY)
+            self.assertEqual(cf_version, CORNFLOW_VERSION)
+
+            # Verify Databricks client was called
+            mock_databricks.from_config.assert_called_once()
+            mock_db_client.is_alive.assert_called_once()
+
+    @patch("cornflow.endpoints.health.Databricks")
+    def test_health_databricks_backend_unhealthy(self, mock_databricks):
+        """Test health endpoint with Databricks backend when service is unhealthy"""
+        self.create_service_user()
+        os.environ["CORNFLOW_SERVICE_USER"] = "testuser4"
+
+        # Mock Databricks client
+        mock_db_client = MagicMock()
+        mock_db_client.is_alive.return_value = False
+        mock_databricks.from_config.return_value = mock_db_client
+
+        # Set Databricks backend
+        with self.app.app_context():
+            self.app.config["CORNFLOW_BACKEND"] = DATABRICKS_BACKEND
+
+            response = self.client.get(HEALTH_URL)
+
+            self.assertEqual(200, response.status_code)
+            cf_status = response.json["cornflow_status"]
+            backend_status = response.json["backend_status"]
+
+            self.assertEqual(cf_status, STATUS_HEALTHY)
+            self.assertEqual(backend_status, STATUS_UNHEALTHY)
+
+            # Verify Databricks client was called
+            mock_databricks.from_config.assert_called_once()
+            mock_db_client.is_alive.assert_called_once()
+
+    def test_health_unsupported_backend(self):
+        """Test health endpoint with unsupported backend raises EndpointNotImplemented"""
+        self.create_service_user()
+        os.environ["CORNFLOW_SERVICE_USER"] = "testuser4"
+
+        # Set an unsupported backend value
+        with self.app.app_context():
+            self.app.config["CORNFLOW_BACKEND"] = 999  # Invalid backend value
+
+            response = self.client.get(HEALTH_URL)
+
+            self.assertEqual(501, response.status_code)
+            self.assertIn("error", response.json)
+            self.assertEqual(response.json["error"], "Endpoint not implemented")

cornflow/tests/unit/test_main_alarms.py

@@ -5,7 +5,7 @@
 import json
 
 # Imports from internal modules
-from cornflow.models import MainAlarmsModel, AlarmsModel
+from cornflow.models import MainAlarmsModel
 from cornflow.tests.const import MAIN_ALARMS_URL, ALARMS_URL
 from cornflow.tests.custom_test_case import CustomTestCase
 

cornflow/tests/unit/test_roles.py

@@ -251,7 +251,8 @@ class TestUserRolesListEndpoint(CustomTestCase):
                 },
             )
             self.assertEqual(200, response.status_code)
-            self.assertEqual(self.payload, response.json)
+            self.assertCountEqual(self.payload, response.json)
+
 
     def test_get_user_roles_not_authorized_user(self):
         for role in ROLES_MAP:

cornflow/tests/unit/test_schema_from_models.py

@@ -81,7 +81,7 @@
 #         }
 #         required_instance = {"id", "name", "data_hash"}
 #         foreign_keys = [
-#             ("permission_dag", "dag_id", "deployed_dags.id"),
+#             ("permission_dag", "dag_id", "deployed_workflows.id"),
 #             ("permission_dag", "user_id", "users.id"),
 #             ("permission_view", "action_id", "actions.id"),
 #             ("permission_view", "api_view_id", "api_view.id"),

cornflow/tests/unit/test_schemas.py

@@ -189,7 +189,7 @@ class TestNewSchemaEndpointOpen(CustomTestCase):
 
     def test_get_all_schemas(self):
         schemas = self.get_one_row(self.url, {}, 200, False, keys_to_check=["name"])
-        dags = [{"name": dag} for dag in ["solve_model_dag", "gc", "timer"]]
+        dags = [{"name": dag} for dag in ["solve_model_dag", "gc", "timer", "979073949072767"]]
 
         self.assertEqual(dags, schemas)
 

cornflow/tests/unit/test_sign_up.py

@@ -1,18 +1,25 @@
 """
 Unit test for the sign-up endpoint
 """
-from cornflow.commands import access_init_command
-from cornflow.commands.dag import register_deployed_dags_command_test
 
 # Import from libraries
-from flask_testing import TestCase
+
+# Import from internal modules
+
 import json
+from unittest.mock import patch
+
+# Import from libraries
+from flask_testing import TestCase
 
 # Import from internal modules
 from cornflow.app import create_app
-from cornflow.models import UserModel, UserRoleModel
-from cornflow.shared.const import PLANNER_ROLE
+from cornflow.commands import access_init_command
+from cornflow.commands.dag import register_deployed_dags_command_test
+from cornflow.models import UserModel, UserRoleModel, ViewModel, PermissionViewRoleModel
 from cornflow.shared import db
+from cornflow.shared.authentication import Auth
+from cornflow.shared.const import PLANNER_ROLE, ADMIN_ROLE, POST_ACTION, NO_SIGNUP, SIGNUP_WITH_AUTH
 from cornflow.tests.const import SIGNUP_URL
 
 
@@ -95,7 +102,7 @@ class TestSignUp(TestCase):
 class TestSignUpDeactivated(TestCase):
     def create_app(self):
         app = create_app("testing")
-        app.config["SIGNUP_ACTIVATED"] = 0
+        app.config["SIGNUP_ACTIVATED"] = NO_SIGNUP
         return app
 
     def setUp(self):
@@ -120,3 +127,171 @@ class TestSignUpDeactivated(TestCase):
         )
 
         self.assertEqual(response.status_code, 400)
+
+
+class TestSignUpAuthenticated(TestCase):
+    """Test the authenticated signup endpoint (SIGNUP_ACTIVATED=SIGNUP_WITH_AUTH)"""
+
+    def create_app(self):
+        with patch("cornflow.config.Testing.SIGNUP_ACTIVATED", SIGNUP_WITH_AUTH):
+            app = create_app("testing")
+        return app
+
+    def setUp(self):
+        db.create_all()
+        access_init_command(verbose=False)
+        register_deployed_dags_command_test(verbose=False)
+
+        # Create test data
+        self.data = {
+            "username": "testname",
+            "email": "test@test.com",
+            "password": "Testpassword1!",
+        }
+
+        # Create an admin user for testing
+        self.admin_user = UserModel(
+            {
+                "username": "admin",
+                "email": "admin@test.com",
+                "password": "Adminpassword1!",
+            }
+        )
+        self.admin_user.save()
+
+        # Assign admin role to the user
+        admin_role = UserRoleModel(
+            {"user_id": self.admin_user.id, "role_id": ADMIN_ROLE}
+        )
+        admin_role.save()
+
+        # Create a regular user for testing
+        self.regular_user = UserModel(
+            {
+                "username": "regular",
+                "email": "regular@test.com",
+                "password": "Regularpassword1!",
+            }
+        )
+        self.regular_user.save()
+
+        # Assign planner role to the user
+        planner_role = UserRoleModel(
+            {"user_id": self.regular_user.id, "role_id": PLANNER_ROLE}
+        )
+        planner_role.save()
+
+    def tearDown(self):
+        db.session.remove()
+        db.drop_all()
+
+    def get_auth_token(self, user):
+        """Helper method to get authentication token for a user"""
+        auth = Auth()
+        return auth.generate_token(user.id)
+
+    def test_authenticated_signup_admin_can_register(self):
+        """Test that admin users can register new users"""
+        payload = self.data
+        admin_token = self.get_auth_token(self.admin_user)
+
+        response = self.client.post(
+            SIGNUP_URL,
+            data=json.dumps(payload),
+            follow_redirects=True,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {admin_token}",
+            },
+        )
+
+        self.assertEqual(201, response.status_code)
+        self.assertEqual(str, type(response.json["token"]))
+        self.assertEqual(int, type(response.json["id"]))
+        self.assertEqual(
+            PLANNER_ROLE,
+            UserRoleModel.query.filter_by(user_id=response.json["id"]).first().role_id,
+        )
+        self.assertNotEqual(None, UserModel.get_one_user_by_email(self.data["email"]))
+
+    def test_authenticated_signup_regular_user_cannot_register(self):
+        """Test that regular users cannot register new users"""
+        payload = self.data
+        regular_token = self.get_auth_token(self.regular_user)
+
+        response = self.client.post(
+            SIGNUP_URL,
+            data=json.dumps(payload),
+            follow_redirects=True,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {regular_token}",
+            },
+        )
+
+        # Should return 403 Forbidden due to insufficient permissions
+        self.assertEqual(403, response.status_code)
+        self.assertIn("error", response.json)
+
+    def test_authenticated_signup_no_auth_header_fails(self):
+        """Test that signup fails without authentication header"""
+        payload = self.data
+
+        response = self.client.post(
+            SIGNUP_URL,
+            data=json.dumps(payload),
+            follow_redirects=True,
+            headers={"Content-Type": "application/json"},
+        )
+
+        # Should return 400 Bad Request due to missing authorization
+        self.assertEqual(400, response.status_code)
+        self.assertIn("error", response.json)
+
+    def test_authenticated_signup_invalid_token_fails(self):
+        """Test that signup fails with invalid token"""
+        payload = self.data
+
+        response = self.client.post(
+            SIGNUP_URL,
+            data=json.dumps(payload),
+            follow_redirects=True,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": "Bearer invalid_token",
+            },
+        )
+
+        # Should return 400 Bad Request due to invalid token
+        self.assertEqual(400, response.status_code)
+        self.assertIn("error", response.json)
+
+    def test_signup_permissions_are_registered_in_database(self):
+        """Test that signup permissions are properly registered in the database"""
+        # Check that the signup endpoint exists in the views table
+        signup_view = ViewModel.query.filter_by(name="signup").first()
+        self.assertIsNotNone(
+            signup_view, "Signup endpoint should be registered in views table"
+        )
+        self.assertEqual("/signup/", signup_view.url_rule)
+
+        # Check that admin role has permissions for signup endpoint
+        admin_permissions = PermissionViewRoleModel.query.filter_by(
+            role_id=ADMIN_ROLE, api_view_id=signup_view.id
+        ).all()
+
+        # Admin should have POST permission for signup endpoint
+        self.assertGreater(
+            len(admin_permissions),
+            0,
+            "Admin should have permissions for signup endpoint",
+        )
+
+        # Verify that the permission is for POST action
+        post_permission = PermissionViewRoleModel.query.filter_by(
+            role_id=ADMIN_ROLE, api_view_id=signup_view.id, action_id=POST_ACTION
+        ).first()
+
+        self.assertIsNotNone(
+            post_permission, "Admin should have POST permission for signup endpoint"
+        )

cornflow/tests/unit/tools.py

@@ -1,13 +1,96 @@
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
+from flask import Flask
+import json
+import os
+
+from cornflow.shared.const import (
+    DATABRICKS_TERMINATE_STATE,
+    DATABRICKS_FINISH_TO_STATE_MAP,
+)
+
+
+def create_test_app():
+    app = Flask(__name__)
+    app.config["CORNFLOW_BACKEND"] = 2
+    return app
 
 
 def patch_af_client(af_client_class):
-    af_client_mock = Mock()
-    responses_mock = Mock()
-    responses_mock.json.return_value = {"is_paused": False, "dag_run_id": "12345", "state": "success"}
-    af_client_mock.is_alive.return_value = True
-    af_client_mock.get_dag_info.return_value = responses_mock
-    af_client_mock.run_dag.return_value = responses_mock
-    af_client_mock.get_dag_run_status.return_value = responses_mock
-    af_client_mock.set_dag_run_to_fail.return_value = None
-    af_client_class.from_config.return_value = af_client_mock
+    with patch("cornflow.endpoints.execution.current_app.config") as mock_config:
+        mock_config.__getitem__.side_effect = lambda key: (
+            1 if key == "CORNFLOW_BACKEND" else {}
+        )
+        af_client_mock = Mock()
+        responses_mock = Mock()
+        responses_mock.json.return_value = {
+            "is_paused": False,
+            "dag_run_id": "12345",
+            "state": "success",
+        }
+        af_client_mock.is_alive.return_value = True
+        af_client_mock.get_workflow_info.return_value = responses_mock
+
+        # Configurar get_workflow_info
+        schema_info_mock = Mock()
+        schema_info_mock.json.return_value = {"is_paused": False}
+        af_client_mock.get_workflow_info.return_value = schema_info_mock
+
+        # Configurar run_workflow
+        run_response_mock = Mock()
+        run_response_mock.json.return_value = {"dag_run_id": "12345"}
+        af_client_mock.run_workflow.return_value = run_response_mock
+
+        # Configurar get_run_status
+        status_mock = Mock()
+        status_mock.json.return_value = {"state": "success"}
+        af_client_mock.get_run_status.return_value = status_mock
+
+        af_client_mock.run_dag.return_value = responses_mock
+        af_client_mock.set_dag_run_to_fail.return_value = None
+        af_client_class.from_config.return_value = af_client_mock
+
+
+def patch_db_client(db_client_class):
+    mock_config = {"CORNFLOW_BACKEND": 2}
+
+    with patch("cornflow.endpoints.execution.current_app.config", mock_config):
+        db_client_mock = Mock()
+        responses_mock = Mock()
+        responses_mock.json.return_value = {
+            "status": {"state": "SUCCESS", "termination_details": {"code": "SUCCESS"}}
+        }
+        response_run_workflow = Mock()
+        response_run_workflow.json.return_value = {
+            "run_id": 350148078719367,
+            "number_in_job": 350148078719367,
+        }
+        response_get_workflow_info = Mock()
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        test_data_dir = os.path.join(os.path.dirname(current_dir), "data")
+        with open(
+            os.path.join(test_data_dir, "patch_databricks_get_orch_info.json")
+        ) as f:
+            response_get_workflow_info.json.return_value = json.load(f)
+        response_get_run_status = Mock()
+        with open(
+            os.path.join(test_data_dir, "patch_databricks_get_run_status.json")
+        ) as f:
+            response_get_run_status.json.return_value = json.load(f)
+        state = response_get_run_status.json.return_value["status"]["state"]
+        if state == DATABRICKS_TERMINATE_STATE:
+            if (
+                response_get_run_status.json.return_value["status"][
+                    "termination_details"
+                ]["code"]
+                in DATABRICKS_FINISH_TO_STATE_MAP.keys()
+            ):
+                response_get_run_status = response_get_run_status.json.return_value[
+                    "status"
+                ]["termination_details"]["code"]
+            else:
+                response_get_run_status = "OTHER_FINISH_ERROR"
+        db_client_mock.is_alive.return_value = True
+        db_client_mock.get_workflow_info.return_value = response_get_workflow_info
+        db_client_mock.run_workflow.return_value = response_run_workflow
+        db_client_mock.get_run_status.return_value = response_get_run_status
+        db_client_class.from_config.return_value = db_client_mock

{cornflow-1.2.3a5.dist-info → cornflow-1.3.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cornflow
-Version: 1.2.3a5
+Version: 1.3.0rc1
 Summary: cornflow is an open source multi-solver optimization server with a REST API built using flask.
 Home-page: https://github.com/baobabsoluciones/cornflow
 Author: baobab soluciones
@@ -14,7 +14,7 @@ Requires-Dist: alembic==1.9.2
 Requires-Dist: apispec<=6.3.0
 Requires-Dist: cachetools==5.3.3
 Requires-Dist: click<=8.1.7
-Requires-Dist: cornflow-client>=1.2.3.a5
+Requires-Dist: cornflow-client==1.3.0rc1
 Requires-Dist: cryptography<=44.0.1
 Requires-Dist: disposable-email-domains>=0.0.86
 Requires-Dist: Flask==2.3.2
@@ -37,7 +37,7 @@ Requires-Dist: PuLP<=2.9.0
 Requires-Dist: psycopg2<=2.9.9
 Requires-Dist: PyJWT<=2.8.0
 Requires-Dist: pytups>=0.86.2
-Requires-Dist: requests<=2.32.3
+Requires-Dist: requests<=2.32.4
 Requires-Dist: SQLAlchemy==1.3.21
 Requires-Dist: webargs<=8.3.0
 Requires-Dist: Werkzeug==3.0.6