cornflow 1.0.11a1__py3-none-any.whl → 1.1.0__py3-none-any.whl

cornflow/tests/custom_test_case.py

@@ -5,6 +5,9 @@ This file contains the different custom test classes used to generalize the unit
 # Import from libraries
 import logging as log
 from datetime import datetime, timedelta
+
+from typing import List
+
 from flask import current_app
 from flask_testing import TestCase
 import json
@@ -27,7 +30,6 @@ from cornflow.tests.const import (
     TOKEN_URL,
 )
 
-
 try:
     date_from_str = datetime.fromisoformat
 except:
@@ -172,7 +174,9 @@ class CustomTestCase(TestCase):
                 self.assertEqual(getattr(row, key), payload[key])
         return row.id
 
-    def get_rows(self, url, data, token=None, check_data=True):
+    def get_rows(
+        self, url, data, token=None, check_data=True, keys_to_check: List[str] = None
+    ):
         token = token or self.token
 
         codes = [
@@ -187,6 +191,8 @@ class CustomTestCase(TestCase):
         if check_data:
             for i in range(len(data)):
                 self.assertEqual(rows_data[i]["id"], codes[i])
+                if keys_to_check:
+                    self.assertCountEqual(list(rows_data[i].keys()), keys_to_check)
                 for key in self.get_keys_to_check(data[i]):
                     self.assertIn(key, rows_data[i])
                     if key in data[i]:
@@ -199,7 +205,13 @@ class CustomTestCase(TestCase):
         return payload.keys()
 
     def get_one_row(
-        self, url, payload, expected_status=200, check_payload=True, token=None
+        self,
+        url,
+        payload,
+        expected_status=200,
+        check_payload=True,
+        token=None,
+        keys_to_check: List[str] = None,
     ):
         token = token or self.token
 
@@ -210,6 +222,8 @@ class CustomTestCase(TestCase):
         self.assertEqual(expected_status, row.status_code)
         if not check_payload:
             return row.json
+        if keys_to_check:
+            self.assertCountEqual(list(row.json.keys()), keys_to_check)
         self.assertEqual(row.json["id"], payload["id"])
         for key in self.get_keys_to_check(payload):
             self.assertIn(key, row.json)

cornflow/tests/integration/test_cornflowclient.py

@@ -35,6 +35,24 @@ class TestCornflowClientBasic(CustomTestCaseLive):
         super().setUp()
         self.items_to_check = ["name", "description"]
 
+    def check_status_evolution(self, execution, end_state=EXEC_STATE_CORRECT):
+        statuses = [execution["state"]]
+        while end_state not in statuses and len(statuses) < 100:
+            time.sleep(1)
+            status = self.client.get_status(execution["id"])
+            statuses.append(status["state"])
+
+        self.assertIn(EXEC_STATE_QUEUED, statuses)
+        self.assertIn(EXEC_STATE_RUNNING, statuses)
+        self.assertIn(end_state, statuses)
+
+        queued_idx = statuses.index(EXEC_STATE_QUEUED)
+        running_idx = statuses.index(EXEC_STATE_RUNNING)
+        end_state_idx = statuses.index(end_state)
+
+        self.assertLess(queued_idx, running_idx)
+        self.assertLess(running_idx, end_state_idx)
+
     def create_new_instance_file(self, mps_file):
         name = "test_instance1"
         description = "description123"
@@ -141,7 +159,6 @@ class TestCornflowClientBasic(CustomTestCaseLive):
 
 
 class TestCornflowClientOpen(TestCornflowClientBasic):
-
     # TODO: user management
     # TODO: infeasible execution
 
@@ -242,7 +259,6 @@ class TestCornflowClientOpen(TestCornflowClientBasic):
         self.client.create_instance(**payload)
 
     def test_new_instance_with_schema_good(self):
-
         payload = load_file(INSTANCE_PATH)
         payload["schema"] = "solve_model_dag"
         self.create_new_instance_payload(payload)
@@ -335,23 +351,13 @@ class TestCornflowClientAdmin(TestCornflowClientBasic):
 
     def test_status_solving(self):
         execution = self.create_instance_and_execution()
-        time.sleep(10)
-        status = self.client.get_status(execution["id"])
-        self.assertEqual(status["state"], EXEC_STATE_CORRECT)
+        self.check_status_evolution(execution, EXEC_STATE_CORRECT)
 
     def test_status_solving_timer(self):
         execution = self.create_timer_instance_and_execution(10)
-        status = self.client.get_status(execution["id"])
-        self.assertEqual(status["state"], EXEC_STATE_QUEUED)
-        time.sleep(5)
-        status = self.client.get_status(execution["id"])
-        self.assertEqual(status["state"], EXEC_STATE_RUNNING)
-        time.sleep(12)
-        status = self.client.get_status(execution["id"])
-        self.assertEqual(status["state"], EXEC_STATE_CORRECT)
+        self.check_status_evolution(execution, EXEC_STATE_CORRECT)
 
     def test_manual_execution(self):
-
         instance_payload = load_file(INSTANCE_PATH)
         one_instance = self.create_new_instance_payload(instance_payload)
         name = "test_execution_name_123"

cornflow/tests/unit/test_cases.py

@@ -201,8 +201,29 @@ class TestCasesRawDataEndpoint(CustomTestCase):
         self.payload.pop("solution")
         self.items_to_check = ["name", "description", "schema", "data"]
         _id = self.create_new_row(self.url, self.model, self.payload)
+        keys_to_check = [
+            "data",
+            "solution_checks",
+            "updated_at",
+            "id",
+            "schema",
+            "data_hash",
+            "path",
+            "solution_hash",
+            "user_id",
+            "indicators",
+            "solution",
+            "is_dir",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
         data = self.get_one_row(
-            self.url + "/" + str(_id) + "/data/", payload={}, check_payload=False
+            self.url + "/" + str(_id) + "/data/",
+            payload={},
+            check_payload=False,
+            keys_to_check=keys_to_check,
         )
         self.assertIsNone(data["solution"])
 
@@ -293,7 +314,21 @@ class TestCaseListEndpoint(BaseTestCases.ListFilters):
         self.url = CASE_URL
 
     def test_get_rows(self):
-        self.get_rows(self.url, self.payloads)
+        keys_to_check = [
+            "data_hash",
+            "created_at",
+            "is_dir",
+            "path",
+            "schema",
+            "description",
+            "solution_hash",
+            "id",
+            "user_id",
+            "updated_at",
+            "name",
+            "indicators",
+        ]
+        self.get_rows(self.url, self.payloads, keys_to_check=keys_to_check)
 
 
 class TestCaseDetailEndpoint(BaseTestCases.DetailEndpoint):
@@ -365,7 +400,19 @@ class TestCaseToInstanceEndpoint(CustomTestCase):
         )
 
         payload = response.json
-        result = self.get_one_row(INSTANCE_URL + payload["id"] + "/", payload)
+        keys_to_check = [
+            "id",
+            "schema",
+            "data_hash",
+            "executions",
+            "user_id",
+            "description",
+            "name",
+            "created_at",
+        ]
+        result = self.get_one_row(
+            INSTANCE_URL + payload["id"] + "/", payload, keys_to_check=keys_to_check
+        )
         dif = self.response_items.symmetric_difference(result.keys())
         self.assertEqual(len(dif), 0)
 
@@ -382,7 +429,23 @@ class TestCaseToInstanceEndpoint(CustomTestCase):
         ]
         self.response_items = set(self.items_to_check)
 
-        result = self.get_one_row(INSTANCE_URL + payload["id"] + "/data/", payload)
+        keys_to_check = [
+            "data",
+            "id",
+            "schema",
+            "data_hash",
+            "user_id",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
+
+        result = self.get_one_row(
+            INSTANCE_URL + payload["id"] + "/data/",
+            payload,
+            keys_to_check=keys_to_check,
+        )
         dif = self.response_items.symmetric_difference(result.keys())
         self.assertEqual(len(dif), 0)
 
@@ -539,11 +602,37 @@ class TestCaseDataEndpoint(CustomTestCase):
         ]
 
     def test_get_data(self):
-        self.get_one_row(self.url + str(self.payload["id"]) + "/data/", self.payload)
+        keys_to_check = [
+            "data",
+            "solution_checks",
+            "updated_at",
+            "id",
+            "schema",
+            "data_hash",
+            "path",
+            "solution_hash",
+            "user_id",
+            "indicators",
+            "solution",
+            "is_dir",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
+        self.get_one_row(
+            self.url + str(self.payload["id"]) + "/data/",
+            self.payload,
+            keys_to_check=keys_to_check,
+        )
 
     def test_get_no_data(self):
         self.get_one_row(
-            self.url + str(500) + "/data/", {}, expected_status=404, check_payload=False
+            self.url + str(500) + "/data/",
+            {},
+            expected_status=404,
+            check_payload=False,
+            keys_to_check=["error"],
         )
 
     def test_get_compressed_data(self):

cornflow/tests/unit/test_cli.py

@@ -131,7 +131,7 @@ class CLITests(TestCase):
         result = runner.invoke(cli, ["views", "init", "-v"])
         self.assertEqual(result.exit_code, 0)
         views = ViewModel.get_all_objects().all()
-        self.assertEqual(len(views), 48)
+        self.assertEqual(len(views), 49)
 
     def test_permissions_entrypoint(self):
         runner = CliRunner()
@@ -155,8 +155,8 @@ class CLITests(TestCase):
         permissions = PermissionViewRoleModel.get_all_objects().all()
         self.assertEqual(len(actions), 5)
         self.assertEqual(len(roles), 4)
-        self.assertEqual(len(views), 48)
-        self.assertEqual(len(permissions), 530)
+        self.assertEqual(len(views), 49)
+        self.assertEqual(len(permissions), 546)
 
     def test_permissions_base_command(self):
         runner = CliRunner()
@@ -171,8 +171,8 @@ class CLITests(TestCase):
         permissions = PermissionViewRoleModel.get_all_objects().all()
         self.assertEqual(len(actions), 5)
         self.assertEqual(len(roles), 4)
-        self.assertEqual(len(views), 48)
-        self.assertEqual(len(permissions), 530)
+        self.assertEqual(len(views), 49)
+        self.assertEqual(len(permissions), 546)
 
     def test_service_entrypoint(self):
         runner = CliRunner()

cornflow/tests/unit/test_dags.py

@@ -24,6 +24,7 @@ from cornflow.tests.const import (
     LOGIN_URL,
     SIGNUP_URL,
     USER_URL,
+    EXECUTION_URL,
 )
 from cornflow.tests.unit.test_executions import TestExecutionsDetailEndpointMock
 from cornflow_client import get_pulp_jsonschema, get_empty_schema
@@ -90,13 +91,31 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         with open(CASE_PATH) as f:
             payload = json.load(f)
+
+        log_json = {
+            "time": 10.3,
+            "solver": "dummy",
+            "status": "feasible",
+            "status_code": 2,
+            "sol_code": 1,
+            "some_other_key": "this should be excluded",
+        }
+
         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",
+            },
         )
         payload_to_check = {**self.payload, **data}
         token = self.create_service_user()
-        data = self.update_row(
+        self.update_row(
             url=DAG_URL + idx + "/",
             payload_to_check=payload_to_check,
             change=data,
@@ -104,19 +123,46 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
             check_payload=False,
         )
 
+        data = self.get_one_row(
+            url=EXECUTION_URL + idx + "/log/",
+            token=token,
+            check_payload=False,
+            payload=self.payload,
+            expected_status=200,
+        )
+
+        for key in data["log"]:
+            self.assertEqual(data["log"][key], log_json[key])
+
+        self.assertNotIn("some_other_key", data["log"].keys())
+
     def test_get_dag(self):
         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"]
         data = self.get_one_row(
             url=DAG_URL + idx + "/",
             token=token,
             check_payload=False,
             payload=self.payload,
+            keys_to_check=keys_to_check,
         )
+        keys_to_check = [
+            "data",
+            "id",
+            "schema",
+            "data_hash",
+            "user_id",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
         instance_data = self.get_one_row(
             url=INSTANCE_URL + self.payload["instance_id"] + "/data/",
             payload=dict(),
             check_payload=False,
+            keys_to_check=keys_to_check,
         )
         self.assertEqual(data["data"], instance_data["data"])
         self.assertEqual(data["config"], self.payload["config"])
@@ -130,6 +176,7 @@ class TestDagDetailEndpoint(TestExecutionsDetailEndpointMock):
             check_payload=False,
             payload=self.payload,
             expected_status=403,
+            keys_to_check=["error"],
         )
 
 

cornflow/tests/unit/test_example_data.py

@@ -1,14 +1,9 @@
-"""
-
-"""
-# General imports
 import json
 
-# Partial imports
-from unittest.mock import patch
 
+from unittest.mock import patch
 
-# Imports from internal modules
+from cornflow.models import PermissionsDAG
 from cornflow.tests.const import EXAMPLE_URL, INSTANCE_PATH
 from cornflow.tests.custom_test_case import CustomTestCase
 
@@ -22,7 +17,18 @@ class TestExampleDataEndpoint(CustomTestCase):
                 temp = json.load(f)
             return temp
 
-        self.example = load_file(INSTANCE_PATH)
+        self.example = [
+            {
+                "name": "test_example_1",
+                "description": "some_description",
+                "instance": load_file(INSTANCE_PATH),
+            },
+            {
+                "name": "test_example_2",
+                "description": "some_description",
+                "instance": load_file(INSTANCE_PATH),
+            },
+        ]
         self.url = EXAMPLE_URL
         self.schema_name = "solve_model_dag"
 
@@ -37,15 +43,82 @@ class TestExampleDataEndpoint(CustomTestCase):
         af_client.get_all_schemas.return_value = [{"name": self.schema_name}]
         return af_client
 
+    def patch_af_client_not_alive(self, Airflow_mock):
+        af_client = Airflow_mock.return_value
+        af_client.is_alive.return_value = False
+        af_client.is_alive.return_value = False
+        return af_client
+
     @patch("cornflow.endpoints.example_data.Airflow.from_config")
-    def test_get_example(self, airflow_init):
+    def test_get_list_of_examples(self, airflow_init):
         af_client = self.patch_af_client(airflow_init)
+        examples = self.get_one_row(
+            f"{self.url}/{self.schema_name}/",
+            {},
+            expected_status=200,
+            check_payload=False,
+        )
+
+        for pos, item in enumerate(examples):
+            self.assertIn("name", item)
+            self.assertEqual(self.example[pos]["name"], item["name"])
+            self.assertIn("description", item)
+            self.assertEqual(self.example[pos]["description"], item["description"])
+
+    @patch("cornflow.endpoints.example_data.Airflow.from_config")
+    def test_get_one_example(self, airflow_init):
+        def load_file(_file):
+            with open(_file) as f:
+                temp = json.load(f)
+            return temp
+
+        af_client = self.patch_af_client(airflow_init)
+        keys_to_check = ["name", "examples"]
         example = self.get_one_row(
-            self.url + "{}/".format(self.schema_name),
+            f"{self.url}/{self.schema_name}/test_example_1/",
             {},
             expected_status=200,
             check_payload=False,
+            keys_to_check=keys_to_check,
         )
-        self.assertIn("examples", example)
+
         self.assertIn("name", example)
-        self.assertEqual(example["examples"], self.example)
+        self.assertEqual("test_example_1", example["name"])
+        self.assertIn("description", example)
+        self.assertIn("instance", example)
+        self.assertEqual(load_file(INSTANCE_PATH), example["instance"])
+
+    @patch("cornflow.endpoints.example_data.Airflow.from_config")
+    def test_airflow_not_available(self, airflow_init):
+        af_client = self.patch_af_client_not_alive(airflow_init)
+        self.get_one_row(
+            f"{self.url}/{self.schema_name}/test_example_1/",
+            {},
+            expected_status=400,
+            check_payload=False,
+        )
+
+        self.get_one_row(
+            f"{self.url}/{self.schema_name}/",
+            {},
+            expected_status=400,
+            check_payload=False,
+        )
+
+    def test_if_no_permission(self):
+        with patch.object(
+            PermissionsDAG, "check_if_has_permissions", return_value=False
+        ) as mock_permission:
+            self.get_one_row(
+                f"{self.url}/{self.schema_name}/",
+                {},
+                expected_status=403,
+                check_payload=False,
+            )
+
+            self.get_one_row(
+                f"{self.url}/{self.schema_name}/test_example_1/",
+                {},
+                expected_status=403,
+                check_payload=False,
+            )