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

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_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,6 +1,7 @@
 """
 
 """
+
 # General imports
 import json
 
@@ -40,11 +41,13 @@ class TestExampleDataEndpoint(CustomTestCase):
     @patch("cornflow.endpoints.example_data.Airflow.from_config")
     def test_get_example(self, airflow_init):
         af_client = self.patch_af_client(airflow_init)
+        keys_to_check = ["name", "examples"]
         example = self.get_one_row(
             self.url + "{}/".format(self.schema_name),
             {},
             expected_status=200,
             check_payload=False,
+            keys_to_check=keys_to_check,
         )
         self.assertIn("examples", example)
         self.assertIn("name", example)

cornflow/tests/unit/test_executions.py

@@ -43,6 +43,21 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
         self.bad_payload = load_file_fk(BAD_EXECUTION_PATH)
         self.payloads = [load_file_fk(f) for f in EXECUTIONS_LIST]
         self.solution = load_file_fk(EXECUTION_SOLUTION_PATH)
+        self.keys_to_check = [
+            "data_hash",
+            "created_at",
+            "config",
+            "state",
+            "message",
+            "schema",
+            "description",
+            "id",
+            "user_id",
+            "log",
+            "instance_id",
+            "name",
+            "indicators",
+        ]
 
     def test_new_execution(self):
         self.create_new_row(self.url, self.model, payload=self.payload)
@@ -115,13 +130,13 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
         self.assertTrue("error" in response.json)
 
     def test_get_executions(self):
-        self.get_rows(self.url, self.payloads)
+        self.get_rows(self.url, self.payloads, keys_to_check=self.keys_to_check)
 
     def test_get_no_executions(self):
         self.get_no_rows(self.url)
 
     def test_get_executions_superadmin(self):
-        self.get_rows(self.url, self.payloads)
+        self.get_rows(self.url, self.payloads, keys_to_check=self.keys_to_check)
         token = self.create_service_user()
         rows = self.client.get(
             self.url, follow_redirects=True, headers=self.get_header_with_auth(token)
@@ -275,15 +290,42 @@ class TestExecutionsDetailEndpoint(
 
     def test_create_delete_instance_load(self):
         idx = self.create_new_row(self.url + "?run=0", self.model, self.payload)
+        keys_to_check = [
+            "message",
+            "id",
+            "schema",
+            "data_hash",
+            "config",
+            "instance_id",
+            "user_id",
+            "indicators",
+            "description",
+            "name",
+            "created_at",
+            "state",
+        ]
         execution = self.get_one_row(
-            self.url + idx, payload={**self.payload, **dict(id=idx)}
+            self.url + idx,
+            payload={**self.payload, **dict(id=idx)},
+            keys_to_check=keys_to_check,
         )
         self.delete_row(self.url + idx + "/")
+        keys_to_check = [
+            "id",
+            "schema",
+            "description",
+            "name",
+            "user_id",
+            "executions",
+            "created_at",
+            "data_hash",
+        ]
         instance = self.get_one_row(
             INSTANCE_URL + execution["instance_id"] + "/",
             payload={},
             expected_status=200,
             check_payload=False,
+            keys_to_check=keys_to_check,
         )
         executions = [execution["id"] for execution in instance["executions"]]
         self.assertFalse(idx in executions)
@@ -351,20 +393,41 @@ class TestExecutionsDataEndpoint(TestExecutionsDetailEndpointMock):
         super().setUp()
         self.response_items = {"id", "name", "data"}
         self.items_to_check = ["name"]
+        self.keys_to_check = [
+            "created_at",
+            "checks",
+            "instance_id",
+            "schema",
+            "data",
+            "user_id",
+            "message",
+            "data_hash",
+            "log",
+            "config",
+            "description",
+            "state",
+            "name",
+            "id",
+        ]
 
     def test_get_one_execution(self):
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         self.url = EXECUTION_URL + idx + "/data/"
         payload = dict(self.payload)
         payload["id"] = idx
-        self.get_one_row(self.url, payload)
+        self.get_one_row(self.url, payload, keys_to_check=self.keys_to_check)
 
     def test_get_one_execution_superadmin(self):
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         payload = dict(self.payload)
         payload["id"] = idx
         token = self.create_service_user()
-        self.get_one_row(EXECUTION_URL + idx + "/data/", payload, token=token)
+        self.get_one_row(
+            EXECUTION_URL + idx + "/data/",
+            payload,
+            token=token,
+            keys_to_check=self.keys_to_check,
+        )
 
 
 class TestExecutionsLogEndpoint(TestExecutionsDetailEndpointMock):
@@ -372,19 +435,42 @@ class TestExecutionsLogEndpoint(TestExecutionsDetailEndpointMock):
         super().setUp()
         self.response_items = {"id", "name", "log", "indicators"}
         self.items_to_check = ["name"]
+        self.keys_to_check = [
+            "created_at",
+            "id",
+            "log_text",
+            "instance_id",
+            "state",
+            "message",
+            "description",
+            "data_hash",
+            "name",
+            "log",
+            "schema",
+            "user_id",
+            "config",
+            "indicators",
+        ]
 
     def test_get_one_execution(self):
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         payload = dict(self.payload)
         payload["id"] = idx
-        self.get_one_row(EXECUTION_URL + idx + "/log/", payload)
+        self.get_one_row(
+            EXECUTION_URL + idx + "/log/", payload, keys_to_check=self.keys_to_check
+        )
 
     def test_get_one_execution_superadmin(self):
         idx = self.create_new_row(EXECUTION_URL_NORUN, self.model, self.payload)
         payload = dict(self.payload)
         payload["id"] = idx
         token = self.create_service_user()
-        self.get_one_row(EXECUTION_URL + idx + "/log/", payload, token=token)
+        self.get_one_row(
+            EXECUTION_URL + idx + "/log/",
+            payload,
+            token=token,
+            keys_to_check=self.keys_to_check,
+        )
 
 
 class TestExecutionsStatusEndpoint(TestExecutionsDetailEndpointMock):
@@ -400,8 +486,12 @@ class TestExecutionsStatusEndpoint(TestExecutionsDetailEndpointMock):
         idx = self.create_new_row(EXECUTION_URL, self.model, self.payload)
         payload = dict(self.payload)
         payload["id"] = idx
+        keys_to_check = ["state", "message", "id", "data_hash"]
         data = self.get_one_row(
-            EXECUTION_URL + idx + "/status/", payload, check_payload=False
+            EXECUTION_URL + idx + "/status/",
+            payload,
+            check_payload=False,
+            keys_to_check=keys_to_check,
         )
         self.assertEqual(data["state"], 1)
 

cornflow/tests/unit/test_instances.py

@@ -36,6 +36,15 @@ class TestInstancesListEndpoint(BaseTestCases.ListFilters):
 
         self.payload = load_file(INSTANCE_PATH)
         self.payloads = [load_file(f) for f in INSTANCES_LIST]
+        self.keys_to_check = [
+            "data_hash",
+            "created_at",
+            "schema",
+            "description",
+            "id",
+            "user_id",
+            "name",
+        ]
 
     def test_new_instance(self):
         self.create_new_row(self.url, self.model, self.payload)
@@ -65,10 +74,10 @@ class TestInstancesListEndpoint(BaseTestCases.ListFilters):
         self.assertTrue("error" in response.json)
 
     def test_get_instances(self):
-        self.get_rows(self.url, self.payloads)
+        self.get_rows(self.url, self.payloads, keys_to_check=self.keys_to_check)
 
     def test_get_instances_superadmin(self):
-        self.get_rows(self.url, self.payloads)
+        self.get_rows(self.url, self.payloads, keys_to_check=self.keys_to_check)
         token = self.create_service_user()
         rows = self.client.get(
             self.url, follow_redirects=True, headers=self.get_header_with_auth(token)
@@ -173,7 +182,20 @@ class TestInstancesDataEndpoint(TestInstancesDetailEndpointBase):
     def test_get_one_instance(self):
         idx = self.create_new_row(self.url, self.model, self.payload)
         payload = {**self.payload, **dict(id=idx)}
-        result = self.get_one_row(INSTANCE_URL + idx + "/data/", payload)
+        keys_to_check = [
+            "data",
+            "id",
+            "schema",
+            "data_hash",
+            "user_id",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
+        result = self.get_one_row(
+            INSTANCE_URL + idx + "/data/", payload, keys_to_check=keys_to_check
+        )
         dif = self.response_items.symmetric_difference(result.keys())
         self.assertEqual(len(dif), 0)
 
@@ -208,6 +230,7 @@ class TestInstancesDataEndpoint(TestInstancesDetailEndpointBase):
             expected_status=404,
             check_payload=False,
             token=token,
+            keys_to_check=["error"],
         )
 
     def test_get_none_instance_planner_all(self):
@@ -232,8 +255,23 @@ class TestAccessPlannerUsers(CustomTestCase):
         idx = self.create_new_row(self.url, self.model, self.payload)
         token = self.create_planner()
         payload = {**self.payload, **dict(id=idx)}
-
-        self.get_one_row(INSTANCE_URL + idx + "/data/", payload, token=token)
+        keys_to_check = [
+            "data",
+            "id",
+            "schema",
+            "data_hash",
+            "user_id",
+            "description",
+            "name",
+            "checks",
+            "created_at",
+        ]
+        self.get_one_row(
+            INSTANCE_URL + idx + "/data/",
+            payload,
+            token=token,
+            keys_to_check=keys_to_check,
+        )
 
     def test_get_all_instance_planner(self):
         # Test planner users can access objects of other users

cornflow/tests/unit/test_main_alarms.py

@@ -1,6 +1,7 @@
 """
 
 """
+
 import json
 
 # Imports from internal modules
@@ -19,7 +20,7 @@ class TestMainAlarmsEndpoint(CustomTestCase):
         payload = {
             "name": "Alarm 1",
             "description": "Description Alarm 1",
-            "criticality": 1
+            "criticality": 1,
         }
         self.id_alarm = self.client.post(
             ALARMS_URL,
@@ -32,7 +33,7 @@ class TestMainAlarmsEndpoint(CustomTestCase):
         payload = {
             "message": "Message Main Alarm 1",
             "criticality": 1,
-            "id_alarm": self.id_alarm
+            "id_alarm": self.id_alarm,
         }
         self.create_new_row(self.url, self.model, payload)
 
@@ -41,23 +42,22 @@ class TestMainAlarmsEndpoint(CustomTestCase):
             {
                 "message": "Message Main Alarm 1",
                 "criticality": 1,
-                "id_alarm": self.id_alarm
+                "id_alarm": self.id_alarm,
             },
             {
                 "message": "Message Main Alarm 2",
                 "criticality": 2,
                 "schema": "solve_model_dag",
-                "id_alarm": self.id_alarm
+                "id_alarm": self.id_alarm,
             },
         ]
+        keys_to_check = ["schema", "id_alarm", "criticality", "id", "message"]
         rows = self.get_rows(
-            self.url,
-            data,
-            check_data=False
+            self.url, data, check_data=False, keys_to_check=keys_to_check
         )
         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])
+                    self.assertEqual(rows_data[i][key], data[i][key])

cornflow/tests/unit/test_schemas.py

@@ -1,6 +1,7 @@
 """
 
 """
+
 # General imports
 import unittest
 
@@ -159,11 +160,20 @@ class TestSchemaEndpoint(CustomTestCase):
         self.schema_name = "solve_model_dag"
 
     def test_get_schema(self):
+        keys_to_check = [
+            "solution_checks",
+            "instance_checks",
+            "config",
+            "solution",
+            "name",
+            "instance",
+        ]
         schemas = self.get_one_row(
             self.url + "{}/".format(self.schema_name),
             {},
             expected_status=200,
             check_payload=False,
+            keys_to_check=keys_to_check,
         )
         self.assertIn("instance", schemas)
         self.assertIn("solution", schemas)
@@ -178,7 +188,7 @@ class TestNewSchemaEndpointOpen(CustomTestCase):
         self.url = SCHEMA_URL
 
     def test_get_all_schemas(self):
-        schemas = self.get_one_row(self.url, {}, 200, False)
+        schemas = self.get_one_row(self.url, {}, 200, False, keys_to_check=["name"])
         dags = [{"name": dag} for dag in ["solve_model_dag", "gc", "timer"]]
 
         self.assertEqual(dags, schemas)
@@ -205,6 +215,7 @@ class TestNewSchemaEndpointNotOpen(CustomTestCase):
             {},
             expected_status=403,
             check_payload=False,
+            keys_to_check=["error"],
         )
         self.assertEqual(
             {"error": "User does not have permission to access this dag"}, schema

cornflow/tests/unit/test_token.py

@@ -41,6 +41,23 @@ class TestCheckToken(CheckTokenTestCase.TokenEndpoint):
         self.assertEqual(200, self.response.status_code)
         self.assertEqual(1, self.response.json["valid"])
 
+    def test_token_duration(self):
+        durations = [0.000000000001, 1]
+        asserts = [0, 1]
+        payload = self.data
+        for i in range(2):
+            current_app.config["TOKEN_DURATION"] = durations[i]
+            self.token = self.client.post(
+                LOGIN_URL,
+                data=json.dumps(payload),
+                follow_redirects=True,
+                headers={"Content-Type": "application/json"},
+            ).json["token"]
+
+            self.get_check_token()
+            self.assertEqual(200, self.response.status_code)
+            self.assertEqual(asserts[i], self.response.json["valid"])
+
     def test_get_invalid_token(self):
         self.token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2Mzk4MjAwNzMsImlhdCI6MTYzOTczMzY3Mywic3ViIjoxfQ"
         self.token += ".KzAYFDSrAJoCrnxGqKL2v6fE3oxT2muBgYztF1wcuN8"

cornflow/tests/unit/test_users.py

@@ -1,6 +1,8 @@
 import json
 
+from flask import current_app
 from flask_testing import TestCase
+from datetime import datetime, timedelta
 from cornflow.app import create_app
 from cornflow.commands.access import access_init_command
 from cornflow.commands.dag import register_deployed_dags_command_test
@@ -359,6 +361,20 @@ class TestUserEndpoint(TestCase):
         self.assertEqual(200, response.status_code)
         self.assertIsNotNone(response.json["token"])
 
+    def test_change_password_rotation(self):
+        current_app.config["PWD_ROTATION_TIME"] = 1  # in days
+        payload = {"pwd_last_change": (datetime.utcnow() - timedelta(days=2)).strftime("%Y-%m-%dT%H:%M:%SZ")}
+        self.modify_info(self.planner, self.planner, payload)
+        response = self.log_in(self.planner)
+        self.assertEqual(True, response.json["change_password"])
+
+        payload = {"password": "Newtestpassword1!"}
+        self.modify_info(self.planner, self.planner, payload)
+        self.planner.update(payload)
+        print(self.planner)
+        response = self.log_in(self.planner)
+        self.assertEqual(False, response.json["change_password"])
+
 
 class TestUserModel(TestCase):
     def create_app(self):