cornflow 1.1.0a2__py3-none-any.whl → 1.1.1a1__py3-none-any.whl

cornflow/tests/const.py

@@ -14,6 +14,7 @@ INSTANCE_URL = PREFIX + "/instance/"
 INSTANCE_MPS = _get_file("./data/test_mps.mps")
 INSTANCE_GC_20 = _get_file("./data/gc_20_7.json")
 INSTANCE_FILE_FAIL = _get_file("./unit/test_instances.py")
+INSTANCE_TSP = _get_file("./data/tsp_instance.json")
 
 EXECUTION_PATH = _get_file("./data/new_execution.json")
 BAD_EXECUTION_PATH = _get_file("./data/bad_execution.json")
@@ -34,6 +35,12 @@ CASE_INSTANCE_URL = PREFIX + "/case/instance/"
 FULL_CASE_PATH = _get_file("./data/full_case_raw.json")
 FULL_CASE_LIST = [FULL_CASE_PATH, _get_file("./data/full_case_raw_2.json")]
 
+REPORT_PATH = _get_file("./data/new_report.json")
+REPORT_HTML_FILE_PATH = _get_file("./data/new_report.html")
+REPORT_PDF_FILE_PATH = _get_file("./data/new_report_2.pdf")
+BAD_REPORT_PATH = _get_file("./data/bad_report.json")
+REPORT_URL = PREFIX + "/report/"
+
 JSON_PATCH_GOOD_PATH = _get_file("./data/json_patch_good.json")
 JSON_PATCH_BAD_PATH = _get_file("./data/json_patch_bad.json")
 FULL_CASE_JSON_PATCH_1 = _get_file("./data/full_case_patch.json")

cornflow/tests/{custom_liveServer.py → custom_live_server.py}

@@ -39,7 +39,9 @@ class CustomTestCaseLive(LiveServerTestCase):
         if create_all:
             db.create_all()
         access_init_command(False)
-        register_deployed_dags_command_test(verbose=False)
+        register_deployed_dags_command_test(
+            verbose=False, dags=["solve_model_dag", "gc", "timer", "tsp"]
+        )
         user_data = dict(
             username="testname",
             email="test@test.com",

cornflow/tests/custom_test_case.py

@@ -90,8 +90,8 @@ class CustomTestCase(TestCase):
         self.roles_with_access = []
 
     @staticmethod
-    def get_header_with_auth(token):
-        return {"Content-Type": "application/json", "Authorization": "Bearer " + token}
+    def get_header_with_auth(token, content_type="application/json"):
+        return {"Content-Type": content_type, "Authorization": "Bearer " + token}
 
     def create_user(self, data):
         return self.client.post(
@@ -169,7 +169,6 @@ class CustomTestCase(TestCase):
         self.assertEqual(row.id, response.json["id"])
 
         for key in self.get_keys_to_check(payload):
-            getattr(row, key)
             if key in payload:
                 self.assertEqual(getattr(row, key), payload[key])
         return row.id

cornflow/tests/integration/test_commands.py

@@ -3,7 +3,7 @@ from flask import current_app
 from cornflow.commands.dag import register_deployed_dags_command
 from cornflow.models import DeployedDAG
 from cornflow.tests.const import PUBLIC_DAGS
-from cornflow.tests.custom_liveServer import CustomTestCaseLive
+from cornflow.tests.custom_live_server import CustomTestCaseLive
 
 
 class TestCornflowCommands(CustomTestCaseLive):

cornflow/tests/integration/test_cornflowclient.py

@@ -1,17 +1,17 @@
 """
-
+Main script to run the integration tests of cornflow-server
 """
-# Full imports
+
 import json
-import pulp
 import logging as log
+import os
 import time
+from typing import Callable, Any
 
-# Imports from environment
+import pulp
 from cornflow_client import CornFlowApiError
 from cornflow_client.constants import INSTANCE_SCHEMA, SOLUTION_SCHEMA
 
-# Import internal modules
 from cornflow.app import create_app
 from cornflow.shared.const import (
     EXEC_STATE_CORRECT,
@@ -19,12 +19,13 @@ from cornflow.shared.const import (
     EXEC_STATE_RUNNING,
     EXEC_STATE_QUEUED,
     STATUS_HEALTHY,
+    REPORT_STATE,
 )
-from cornflow.tests.const import INSTANCE_PATH, CASE_PATH
-from cornflow.tests.custom_liveServer import CustomTestCaseLive
+from cornflow.tests.const import INSTANCE_PATH, CASE_PATH, INSTANCE_MPS, INSTANCE_TSP
+from cornflow.tests.custom_live_server import CustomTestCaseLive
 
 
-def load_file(_file):
+def load_file(_file: str):
     with open(_file) as f:
         temp = json.load(f)
     return temp
@@ -34,6 +35,7 @@ class TestCornflowClientBasic(CustomTestCaseLive):
     def setUp(self, create_all=False):
         super().setUp()
         self.items_to_check = ["name", "description"]
+        log.info(f"Start test case name: {self.id()}")
 
     def check_status_evolution(self, execution, end_state=EXEC_STATE_CORRECT):
         statuses = [execution["state"]]
@@ -127,7 +129,7 @@ class TestCornflowClientBasic(CustomTestCaseLive):
         return execution
 
     def create_instance_and_execution(self):
-        one_instance = self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        one_instance = self.create_new_instance(INSTANCE_MPS)
         name = "test_execution_name_123"
         description = "test_execution_description_123"
         schema = "solve_model_dag"
@@ -140,6 +142,31 @@ class TestCornflowClientBasic(CustomTestCaseLive):
         )
         return self.create_new_execution(payload)
 
+    def create_instance_and_execution_report(
+        self,
+        schema="tsp",
+        solver="cpsat",
+        data=None,
+        timeLimit=10,
+        report_name="report",
+    ):
+        name = "test_instance_1"
+        description = "description123"
+        if data is None:
+            data = load_file(INSTANCE_TSP)
+        payload = dict(data=data, name=name, description=description, schema=schema)
+        one_instance = self.create_new_instance_payload(payload)
+        payload = dict(
+            instance_id=one_instance["id"],
+            config=dict(
+                solver=solver, timeLimit=timeLimit, report=dict(name=report_name)
+            ),
+            description="test_execution_description_123",
+            name="test_execution_123",
+            schema=schema,
+        )
+        return self.create_new_execution(payload)
+
     def create_timer_instance_and_execution(self, seconds=5):
         payload = dict(
             data=dict(seconds=seconds),
@@ -157,16 +184,47 @@ class TestCornflowClientBasic(CustomTestCaseLive):
         )
         return self.create_new_execution(payload)
 
+    @staticmethod
+    def try_until_condition(
+        func: Callable,
+        condition: Callable[[Any], bool],
+        number_of_times: int = 10,
+        sleep_time: float = 10,
+    ):
+        for i in range(number_of_times):
+            time.sleep(sleep_time)
+            result = func()
+            if condition(result):
+                return result
+        raise TimeoutError(
+            "Timed out after {} seconds".format(number_of_times * sleep_time)
+        )
+
+    @staticmethod
+    def wait_until_report_finishes(
+        client, execution_id: str, report_status=REPORT_STATE.CORRECT
+    ):
+        def func():
+            my_reports = client.raw.get_results(execution_id).json()["reports"]
+            if len(my_reports) == 0:
+                return None
+            first = my_reports[0]
+            if first["state"] != report_status:
+                return None
+            return first
+
+        return func
+
 
 class TestCornflowClientOpen(TestCornflowClientBasic):
     # TODO: user management
     # TODO: infeasible execution
 
     def test_new_instance_file(self):
-        self.create_new_instance_file("./cornflow/tests/data/test_mps.mps")
+        self.create_new_instance_file(INSTANCE_MPS)
 
     def test_new_instance(self):
-        return self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        return self.create_new_instance(INSTANCE_MPS)
 
     # TODO: reactivate test with new version of cornflow client which allows to pass
     #  optional arguments for the headers of the request
@@ -189,6 +247,49 @@ class TestCornflowClientOpen(TestCornflowClientBasic):
     def test_new_execution(self):
         return self.create_instance_and_execution()
 
+    def test_new_execution_with_tsp_report(self):
+        return self.create_instance_and_execution_report()
+
+    #
+    def test_new_execution_with_tsp_report_wait(self):
+        execution = self.create_instance_and_execution_report()
+        func = self.wait_until_report_finishes(self.client, execution["id"])
+        reports_info = self.try_until_condition(func, lambda v: v is not None, 20, 5)
+        id_report = reports_info["id"]
+        my_name = "./my_report.html"
+        try:
+            os.remove(my_name)
+        except:
+            pass
+        self.client.raw.get_one_report(id_report, "./", my_name)
+        self.assertTrue(os.path.exists(my_name))
+        try:
+            os.remove(my_name)
+        except OSError:
+            pass
+
+    # read header of file? we can parse it with beatifulsoup
+
+    def test_new_execution_with_timer_report_wait(self):
+        payload = dict(
+            solver="default", schema="timer", data={"seconds": 1}, timeLimit=1
+        )
+        execution = self.create_instance_and_execution_report(**payload)
+        func = self.wait_until_report_finishes(self.client, execution["id"])
+        reports_info = self.try_until_condition(func, lambda v: v is not None, 20, 5)
+        id_report = reports_info["id"]
+        my_name = "./my_report.html"
+        try:
+            os.remove(my_name)
+        except:
+            pass
+        self.client.raw.get_one_report(id_report, "./", my_name)
+        self.assertTrue(os.path.exists(my_name))
+        try:
+            os.remove(my_name)
+        except OSError:
+            pass
+
     def test_delete_execution(self):
         execution = self.test_new_execution()
         response = self.client.raw.get_api_for_id("execution/", execution["id"])
@@ -213,7 +314,7 @@ class TestCornflowClientOpen(TestCornflowClientBasic):
         self.assertTrue("error" in response.json())
 
     def test_new_execution_bad_dag_name(self):
-        one_instance = self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        one_instance = self.create_new_instance(INSTANCE_MPS)
         name = "test_execution_name_123"
         description = "test_execution_description_123"
         payload = dict(
@@ -227,7 +328,7 @@ class TestCornflowClientOpen(TestCornflowClientBasic):
         self.assertRaises(CornFlowApiError, _bad_func)
 
     def test_new_execution_with_schema(self):
-        one_instance = self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        one_instance = self.create_new_instance(INSTANCE_MPS)
         name = "test_execution_name_123"
         description = "test_execution_description_123"
         payload = dict(
@@ -309,19 +410,6 @@ class TestCornflowClientAdmin(TestCornflowClientBasic):
     def setUp(self, create_all=False):
         super().setUp()
 
-        # we create a service user:
-        self.create_service_user(
-            dict(username="airflow", pwd="Airflow_test_password1", email="af@cf.com")
-        )
-
-        self.create_service_user(
-            dict(
-                username="service_user@cornflow.com",
-                pwd="Serviceuser_1234",
-                email="service_user@cornflow.com",
-            )
-        )
-
         # we create an admin user
         # we guarantee that the admin is there for airflow
         self.client.token = self.create_admin(
@@ -404,7 +492,7 @@ class TestCornflowClientAdmin(TestCornflowClientBasic):
         self.assertIsNone(execution_data["data"])
 
     def test_edit_one_execution(self):
-        one_instance = self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        one_instance = self.create_new_instance(INSTANCE_MPS)
         payload = dict(
             name="bla",
             config=dict(solver="CBC"),
@@ -455,7 +543,7 @@ class TestCornflowClientAdmin(TestCornflowClientBasic):
         self.assertRaises(CornFlowApiError, _launch_too_soon_func)
 
     def test_check_instance(self):
-        instance = self.create_new_instance("./cornflow/tests/data/test_mps.mps")
+        instance = self.create_new_instance(INSTANCE_MPS)
         data_check_execution = self.client.create_instance_data_check(instance["id"])
         self.assertEqual(data_check_execution["instance_id"], instance["id"])
         status = self.client.get_status(data_check_execution["id"])

cornflow/tests/unit/test_alarms.py

@@ -1,6 +1,10 @@
 """
 
 """
+
+import unittest
+import os
+
 # Imports from internal modules
 from cornflow.models import AlarmsModel
 from cornflow.tests.const import ALARMS_URL
@@ -15,25 +19,34 @@ class TestAlarmsEndpoint(CustomTestCase):
         self.response_items = {"id", "name", "description", "criticality", "schema"}
         self.items_to_check = ["name", "description", "schema", "criticality"]
 
+    @unittest.skipUnless(
+        int(os.getenv("CF_ALARMS_ENDPOINT")) == 1, "No alarms implemented"
+    )
     def test_post_alarm(self):
-        payload = {"name": "Alarm 1", "description": "Description Alarm 1", "criticality": 1}
+        payload = {
+            "name": "Alarm 1",
+            "description": "Description Alarm 1",
+            "criticality": 1,
+        }
         self.create_new_row(self.url, self.model, payload)
 
+    @unittest.skipUnless(
+        int(os.getenv("CF_ALARMS_ENDPOINT")) == 1, "No alarms implemented"
+    )
     def test_get_alarms(self):
         data = [
             {"name": "Alarm 1", "description": "Description Alarm 1", "criticality": 1},
-            {"name": "Alarm 2", "description": "Description Alarm 2", "criticality": 2, "schema": "solve_model_dag"},
+            {
+                "name": "Alarm 2",
+                "description": "Description Alarm 2",
+                "criticality": 2,
+                "schema": "solve_model_dag",
+            },
         ]
-        rows = self.get_rows(
-            self.url,
-            data,
-            check_data=False
-        )
+        rows = self.get_rows(self.url, data, check_data=False)
         rows_data = list(rows.json)
         for i in range(len(data)):
             for key in self.get_keys_to_check(data[i]):
                 self.assertIn(key, rows_data[i])
                 if key in data[i]:
                     self.assertEqual(rows_data[i][key], data[i][key])
-
-

cornflow/tests/unit/test_cli.py

@@ -20,6 +20,11 @@ from cornflow.shared.exceptions import NoPermission, ObjectDoesNotExist
 class CLITests(TestCase):
     def setUp(self):
         db.create_all()
+        self.number_of_views = 52
+        self.number_of_permissions = 574
+        if int(os.getenv("CF_ALARMS_ENDPOINT", 0)) != 1:
+            self.number_of_views = 50
+            self.number_of_permissions = 519
 
     def tearDown(self):
         db.session.remove()
@@ -131,7 +136,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), 49)
+        self.assertEqual(len(views), self.number_of_views)
 
     def test_permissions_entrypoint(self):
         runner = CliRunner()
@@ -155,8 +160,8 @@ class CLITests(TestCase):
         permissions = PermissionViewRoleModel.get_all_objects().all()
         self.assertEqual(len(actions), 5)
         self.assertEqual(len(roles), 4)
-        self.assertEqual(len(views), 49)
-        self.assertEqual(len(permissions), 546)
+        self.assertEqual(len(views), self.number_of_views)
+        self.assertEqual(len(permissions), self.number_of_permissions)
 
     def test_permissions_base_command(self):
         runner = CliRunner()
@@ -171,8 +176,8 @@ class CLITests(TestCase):
         permissions = PermissionViewRoleModel.get_all_objects().all()
         self.assertEqual(len(actions), 5)
         self.assertEqual(len(roles), 4)
-        self.assertEqual(len(views), 49)
-        self.assertEqual(len(permissions), 546)
+        self.assertEqual(len(views), self.number_of_views)
+        self.assertEqual(len(permissions), self.number_of_permissions)
 
     def test_service_entrypoint(self):
         runner = CliRunner()

cornflow/tests/unit/test_commands.py

@@ -1,5 +1,5 @@
 import json
-
+import os
 from flask_testing import TestCase
 
 from cornflow.app import (
@@ -48,7 +48,11 @@ class TestCommands(TestCase):
             "email": "testemail@test.org",
             "password": "Testpassword1!",
         }
-        self.resources = resources + alarms_resources
+
+        if int(os.getenv("CF_ALARMS_ENDPOINT")) == 1:
+            self.resources = resources + alarms_resources
+        else:
+            self.resources = resources
         self.runner = self.create_app().test_cli_runner()
         self.runner.invoke(register_roles, ["-v"])
 

cornflow/tests/unit/test_executions.py

@@ -57,6 +57,7 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
             "instance_id",
             "name",
             "indicators",
+            "reports",
         ]
 
     def test_new_execution(self):
@@ -260,6 +261,7 @@ class TestExecutionsDetailEndpointMock(CustomTestCase):
             "schema",
             "user_id",
             "indicators",
+            "reports",
         }
         # we only check the following because this endpoint does not return data
         self.items_to_check = ["name", "description"]
@@ -303,6 +305,7 @@ class TestExecutionsDetailEndpoint(
             "name",
             "created_at",
             "state",
+            "reports",
         ]
         execution = self.get_one_row(
             self.url + idx,
@@ -408,6 +411,7 @@ class TestExecutionsDataEndpoint(TestExecutionsDetailEndpointMock):
             "state",
             "name",
             "id",
+            "reports",
         ]
 
     def test_get_one_execution(self):
@@ -450,6 +454,7 @@ class TestExecutionsLogEndpoint(TestExecutionsDetailEndpointMock):
             "user_id",
             "config",
             "indicators",
+            "reports",
         ]
 
     def test_get_one_execution(self):

cornflow/tests/unit/test_main_alarms.py

@@ -2,6 +2,8 @@
 
 """
 
+import unittest
+import os
 import json
 
 # Imports from internal modules
@@ -29,6 +31,9 @@ class TestMainAlarmsEndpoint(CustomTestCase):
             headers=self.get_header_with_auth(self.token),
         ).json["id"]
 
+    @unittest.skipUnless(
+        int(os.getenv("CF_ALARMS_ENDPOINT")) == 1, "No alarms implemented"
+    )
     def test_post_main_alarm(self):
         payload = {
             "message": "Message Main Alarm 1",
@@ -37,6 +42,9 @@ class TestMainAlarmsEndpoint(CustomTestCase):
         }
         self.create_new_row(self.url, self.model, payload)
 
+    @unittest.skipUnless(
+        int(os.getenv("CF_ALARMS_ENDPOINT")) == 1, "No alarms implemented"
+    )
     def test_get_main_alarms(self):
         data = [
             {