cornflow 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

cornflow/endpoints/health.py

@@ -4,16 +4,15 @@ It performs a health check to airflow and a health check to cornflow database
 """
 import os
 
-# Import from libraries
-from cornflow_client.airflow.api import Airflow
-from flask import current_app
-from flask_apispec import marshal_with, doc
-
 # Import from internal modules
 from cornflow.endpoints.meta_resource import BaseMetaResource
 from cornflow.models import UserModel
 from cornflow.schemas.health import HealthResponse
-from cornflow.shared.const import STATUS_HEALTHY, STATUS_UNHEALTHY
+from cornflow.shared.const import STATUS_HEALTHY, STATUS_UNHEALTHY, CORNFLOW_VERSION
+# Import from libraries
+from cornflow_client.airflow.api import Airflow
+from flask import current_app
+from flask_apispec import marshal_with, doc
 
 
 class HealthEndpoint(BaseMetaResource):
@@ -30,6 +29,7 @@ class HealthEndpoint(BaseMetaResource):
         af_client = Airflow.from_config(current_app.config)
         airflow_status = STATUS_UNHEALTHY
         cornflow_status = STATUS_UNHEALTHY
+        cornflow_version = CORNFLOW_VERSION
         if af_client.is_alive():
             airflow_status = STATUS_HEALTHY
 
@@ -42,4 +42,4 @@ class HealthEndpoint(BaseMetaResource):
         current_app.logger.info(
             f"Health check: cornflow {cornflow_status}, airflow {airflow_status}"
         )
-        return {"cornflow_status": cornflow_status, "airflow_status": airflow_status}
+        return {"cornflow_status": cornflow_status, "airflow_status": airflow_status, "cornflow_version":cornflow_version}

cornflow/endpoints/instance.py

@@ -34,7 +34,6 @@ from cornflow.shared.exceptions import InvalidUsage, InvalidData
 from cornflow.shared.validators import json_schema_validate_as_string
 
 
-
 # Initialize the schema that all endpoints are going to use
 ALLOWED_EXTENSIONS = {"mps", "lp"}
 
@@ -92,14 +91,18 @@ class InstanceEndpoint(BaseMetaResource):
         # We validate the instance data
         config = current_app.config
 
-        instance_schema = DeployedDAG.get_one_schema(config, data_schema, INSTANCE_SCHEMA)
-        instance_errors = json_schema_validate_as_string(instance_schema, kwargs["data"])
+        instance_schema = DeployedDAG.get_one_schema(
+            config, data_schema, INSTANCE_SCHEMA
+        )
+        instance_errors = json_schema_validate_as_string(
+            instance_schema, kwargs["data"]
+        )
 
         if instance_errors:
             raise InvalidData(
                 payload=dict(jsonschema_errors=instance_errors),
                 log_txt=f"Error while user {self.get_user()} tries to create an instance. "
-                        f"Instance data do not match the jsonschema.",
+                f"Instance data do not match the jsonschema.",
             )
 
         # if we're here, we validated and the data seems to fit the schema
@@ -163,14 +166,18 @@ class InstanceDetailsEndpoint(InstanceDetailsEndpointBase):
 
             config = current_app.config
 
-            instance_schema = DeployedDAG.get_one_schema(config, schema, INSTANCE_SCHEMA)
-            instance_errors = json_schema_validate_as_string(instance_schema, kwargs["data"])
+            instance_schema = DeployedDAG.get_one_schema(
+                config, schema, INSTANCE_SCHEMA
+            )
+            instance_errors = json_schema_validate_as_string(
+                instance_schema, kwargs["data"]
+            )
 
             if instance_errors:
                 raise InvalidData(
                     payload=dict(jsonschema_errors=instance_errors),
                     log_txt=f"Error while user {self.get_user()} tries to create an instance. "
-                            f"Instance data do not match the jsonschema.",
+                    f"Instance data do not match the jsonschema.",
                 )
 
         response = self.put_detail(data=kwargs, user=self.get_user(), idx=idx)
@@ -268,15 +275,35 @@ class InstanceFileEndpoint(BaseMetaResource):
         sense = 1 if minimize else -1
         try:
             _vars, problem = pulp.LpProblem.fromMPS(filename, sense=sense)
-        except:
+        except FileNotFoundError as e:
+            # Handle file not found specifically
             raise InvalidUsage(
-                error="There was an error reading the file",
-                log_txt=f"Error while user {self.get_user()} tries to create instance from mps file. "
-                f"There was an error reading the file.",
+                error=f"MPS file not found: {filename}",
+                log_txt=f"Error for user {self.get_user()}: MPS file '{filename}' not found. Details: {e}",
+                status_code=404,
+            ) from e
+        except PermissionError as e:
+            # Handle permission issues
+            raise InvalidUsage(
+                error=f"Permission denied reading MPS file: {filename}",
+                log_txt=f"Error for user {self.get_user()}: Permission denied for MPS file '{filename}'. Details: {e}",
+                status_code=403,
+            ) from e
+        except (ValueError, pulp.PulpError, OSError, IndexError) as e:
+            # Catch parsing errors, PuLP errors, and other IO errors
+            # Handle parsing, PuLP, or other OS errors
+            current_app.logger.error(
+                f"Error parsing MPS file {filename} for user {self.get_user()}: {e}",
+                exc_info=True,
             )
+            raise InvalidUsage(
+                error="Error reading or parsing the MPS file.",
+                log_txt=f"Error while user {self.get_user()} tries to create instance from MPS file {filename}. Details: {e}",
+            ) from e
+
         try:
             os.remove(filename)
-        except:
+        except FileNotFoundError:
             pass
 
         pb_data = dict(

cornflow/endpoints/meta_resource.py

@@ -1,6 +1,7 @@
 """
 This file has all the logic shared for all the resources
 """
+
 # Import from external libraries
 from flask_restful import Resource
 from flask import g, request
@@ -13,7 +14,6 @@ from cornflow.shared.const import ALL_DEFAULT_ROLES
 from cornflow.shared.exceptions import InvalidUsage, ObjectDoesNotExist, NoPermission
 
 
-
 class BaseMetaResource(Resource, MethodResource):
     """
     The base resource from all methods inherit from.
@@ -30,7 +30,6 @@ class BaseMetaResource(Resource, MethodResource):
         self.auth_class = None
         self.dependents = None
         self.unique = None
-        pass
 
     """
     METHODS USED FOR THE BASIC CRUD OPERATIONS: GET, POST, PUT, PATCH, DELETE 
@@ -121,7 +120,7 @@ class BaseMetaResource(Resource, MethodResource):
         """
         item = self.data_model.get_one_object(**kwargs)
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
 
         data = dict(data)
 
@@ -144,7 +143,7 @@ class BaseMetaResource(Resource, MethodResource):
         item = self.data_model.get_one_object(**kwargs)
 
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
 
         data = dict(data)
 
@@ -164,7 +163,7 @@ class BaseMetaResource(Resource, MethodResource):
         """
         item = self.data_model.get_one_object(**kwargs)
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
         if self.dependents is not None:
             for element in getattr(item, self.dependents):
                 element.delete()

cornflow/schemas/execution.py

@@ -95,7 +95,7 @@ class ExecutionDagPostRequest(ExecutionRequest, ExecutionDagRequest):
 
 
 class ExecutionDetailsEndpointResponse(BaseDataEndpointResponse):
-    config = fields.Nested(ConfigSchemaResponse)
+    config = fields.Raw()
     instance_id = fields.Str()
     state = fields.Int()
     message = fields.Str(attribute="state_message")
@@ -112,6 +112,14 @@ class ExecutionDetailsEndpointWithIndicatorsResponse(ExecutionDetailsEndpointRes
         return indicators_string[1:-1]
 
     indicators = fields.Method("get_indicators")
+    updated_at = fields.DateTime(dump_only=True)
+
+    def get_username(self, obj):
+        if hasattr(obj, "user") and obj.user is not None:
+            return obj.user.username
+        return None
+
+    username = fields.Method("get_username")
 
 
 class ExecutionDetailsWithIndicatorsAndLogResponse(

cornflow/schemas/health.py

@@ -5,3 +5,4 @@ class HealthResponse(Schema):
 
     cornflow_status = fields.Str()
     airflow_status = fields.Str()
+    cornflow_version = fields.Str()

cornflow/shared/authentication/auth.py

@@ -2,15 +2,16 @@
 This file contains the auth class that can be used for authentication on the request to the REST API
 """
 
-# Imports from external libraries
-import jwt
-import requests
-from jwt.algorithms import RSAAlgorithm
 from datetime import datetime, timedelta, timezone
-from flask import request, g, current_app, Request
 from functools import wraps
 from typing import Tuple
+
+# Imports from external libraries
+import jwt
+import requests
 from cachetools import TTLCache
+from flask import request, g, current_app, Request
+from jwt.algorithms import RSAAlgorithm
 from werkzeug.datastructures import Headers
 
 # Imports from internal modules
@@ -31,7 +32,6 @@ from cornflow.shared.exceptions import (
     InvalidData,
     InvalidUsage,
     NoPermission,
-    ObjectDoesNotExist,
 )
 
 # Cache for storing public keys with 1 hour TTL
@@ -122,15 +122,13 @@ class Auth:
     def decode_token(token: str = None) -> dict:
         """
         Decodes a given JSON Web token and extracts the username from the sub claim.
-        Works with both internal tokens and OpenID tokens.
+        Works with both internal tokens and OpenID tokens by attempting verification methods sequentially.
 
         :param str token: the given JSON Web Token
         :return: dictionary containing the username from the token's sub claim
         :rtype: dict
         """
-
         if token is None:
-
             raise InvalidCredentials(
                 "Must provide a token in Authorization header",
                 log_txt="Error while trying to decode token. Token is missing.",
@@ -138,48 +136,81 @@ class Auth:
             )
 
         try:
-            # First try to decode header to validate basic token structure
-
-            unverified_payload = jwt.decode(token, options={"verify_signature": False})
-            issuer = unverified_payload.get("iss")
-
-            # For internal tokens
-            if issuer == INTERNAL_TOKEN_ISSUER:
-
-                return jwt.decode(
-                    token, current_app.config["SECRET_TOKEN_KEY"], algorithms="HS256"
-                )
-
-            # For OpenID tokens
-            if current_app.config["AUTH_TYPE"] == AUTH_OID:
-
-                return Auth().verify_token(
-                    token,
-                    current_app.config["OID_PROVIDER"],
-                    current_app.config["OID_EXPECTED_AUDIENCE"],
-                )
-
-            # If we get here, the issuer is not valid
-
-            raise InvalidCredentials(
-                "Invalid token issuer. Token must be issued by a valid provider",
-                log_txt="Error while trying to decode token. Invalid issuer.",
-                status_code=400,
+            # Attempt 1: Verify as an internal token (HS256)
+            payload = jwt.decode(
+                token, current_app.config["SECRET_TOKEN_KEY"], algorithms=["HS256"]
             )
+            if payload.get("iss") != INTERNAL_TOKEN_ISSUER:
+                raise jwt.InvalidIssuerError(
+                    "Internal token issuer mismatch after verification"
+                )
+            return payload
 
         except jwt.ExpiredSignatureError:
-
+            # Handle expiration specifically, could apply to either token type if caught here first
             raise InvalidCredentials(
                 "The token has expired, please login again",
                 log_txt="Error while trying to decode token. The token has expired.",
                 status_code=400,
             )
-        except jwt.InvalidTokenError as e:
-
+        except (
+            jwt.InvalidSignatureError,
+            jwt.DecodeError,
+            jwt.InvalidTokenError,
+        ) as e_internal:
+            # Internal verification failed (signature, format, etc.). Try OIDC if configured.
+            if current_app.config["AUTH_TYPE"] == AUTH_OID:
+                try:
+                    # Attempt 2: Verify as an OIDC token (RS256) using the dedicated method
+                    return Auth().verify_token(
+                        token,
+                        current_app.config["OID_PROVIDER"],
+                        current_app.config["OID_EXPECTED_AUDIENCE"],
+                    )
+                except jwt.ExpiredSignatureError:
+                    # OIDC token expired
+                    raise InvalidCredentials(
+                        "The token has expired, please login again",
+                        log_txt="Error while trying to decode OIDC token. The token has expired.",
+                        status_code=400,
+                    )
+                except (
+                    jwt.InvalidTokenError,
+                    InvalidCredentials,
+                    CommunicationError,
+                ) as e_oidc:
+                    # OIDC verification failed (JWT format, signature, kid, audience, issuer, comms error)
+                    # Log details for debugging but return a generic error to the client.
+                    log_message = (
+                        f"Error decoding token. Internal verification failed ({type(e_internal).__name__}). "
+                        f"OIDC verification failed ({type(e_oidc).__name__}: {str(e_oidc)})."
+                    )
+                    current_app.logger.warning(log_message)
+                    raise InvalidCredentials(
+                        "Invalid token format, signature, or configuration",
+                        log_txt=log_message,
+                        status_code=400,
+                    )
+            else:
+                # Internal verification failed, and OIDC is not configured
+                log_message = (
+                    f"Error decoding token. Internal verification failed ({type(e_internal).__name__}). "
+                    f"OIDC is not configured."
+                )
+                current_app.logger.warning(log_message)
+                raise InvalidCredentials(
+                    "Invalid token format or signature",
+                    log_txt=log_message,
+                    status_code=400,
+                )
+        except Exception as e:
+            # Catch any other unexpected errors during the process
+            log_message = f"Unexpected error during token decoding: {str(e)}"
+            current_app.logger.error(log_message)
             raise InvalidCredentials(
-                "Invalid token format or signature",
-                log_txt=f"Error while trying to decode token. The token format is invalid: {str(e)}",
-                status_code=400,
+                "Could not decode or verify token due to an unexpected server error",
+                log_txt=log_message,
+                status_code=500,
             )
 
     def get_token_from_header(self, headers: Headers = None) -> str:
@@ -365,10 +396,10 @@ class Auth:
                 "The permission for this endpoint is not in the database."
             )
             raise NoPermission(
-                error="You do not have permission to access this endpoint",
+                error="The permission for this endpoint is not in the database.",
                 status_code=403,
                 log_txt=f"Error while user {user_id} tries to access endpoint. "
-                f"The user does not permission to access. ",
+                f"The permission for this endpoint is not in the database.",
             )
 
         for role in user_roles:
@@ -383,7 +414,7 @@ class Auth:
             error="You do not have permission to access this endpoint",
             status_code=403,
             log_txt=f"Error while user {user_id} tries to access endpoint {view_id} with action {action_id}. "
-            f"The user does not permission to access. ",
+            f"The user does not have permission to access. ",
         )
 
     @staticmethod

cornflow/shared/const.py

@@ -1,7 +1,7 @@
 """
 In this file we import the values for different constants on cornflow server
 """
-
+CORNFLOW_VERSION = "1.2.3"
 INTERNAL_TOKEN_ISSUER = "cornflow"
 
 # endpoints responses for health check
@@ -112,3 +112,12 @@ BASE_PERMISSION_ASSIGNATION = [
 EXTRA_PERMISSION_ASSIGNATION = [
     (VIEWER_ROLE, PUT_ACTION, "user-detail"),
 ]
+
+# migrations constants
+MIGRATIONS_DEFAULT_PATH = "./cornflow/migrations"
+
+# Costants for messages that are given back on exceptions
+AIRFLOW_NOT_REACHABLE_MSG = "Airflow is not reachable"
+DAG_PAUSED_MSG = "The dag exists but it is paused in airflow"
+AIRFLOW_ERROR_MSG = "Airflow responded with an error:"
+DATA_DOES_NOT_EXIST_MSG = "The data entity does not exist on the database"

cornflow/shared/exceptions.py

@@ -9,6 +9,8 @@ from cornflow_client.constants import AirflowError
 from werkzeug.exceptions import HTTPException
 import traceback
 
+from cornflow.shared.const import DATA_DOES_NOT_EXIST_MSG
+
 
 class InvalidUsage(Exception):
     """
@@ -48,7 +50,7 @@ class ObjectDoesNotExist(InvalidUsage):
     """
 
     status_code = 404
-    error = "The object does not exist"
+    error = DATA_DOES_NOT_EXIST_MSG
 
 
 class ObjectAlreadyExists(InvalidUsage):

cornflow/shared/utils_tables.py

@@ -2,6 +2,7 @@
 import inspect
 import os
 import sys
+import collections
 
 from importlib import import_module
 from sqlalchemy.dialects.postgresql import TEXT
@@ -31,14 +32,42 @@ def import_models():
 
 
 def all_subclasses(cls, models=None):
-    subclasses = set()
+    """Finds all direct and indirect subclasses of a given class.
+
+    Optionally filters a provided list of models first.
+
+    Args:
+        cls: The base class to find subclasses for.
+        models: An optional iterable of classes to pre-filter.
+
+    Returns:
+        A set containing all subclasses found.
+    """
+    filtered_subclasses = set()
     if models is not None:
         for val in models:
-            if issubclass(val, cls):
-                subclasses.add(val)
+            # Ensure val is a class before checking issubclass
+            if isinstance(val, type) and issubclass(val, cls):
+                filtered_subclasses.add(val)
+
+    all_descendants = set()
+    # Use a deque for efficient pop(0)
+    queue = collections.deque(cls.__subclasses__())
+    # Keep track of visited classes during the traversal to handle potential complex hierarchies
+    # (though direct subclass relationships shouldn't form cycles)
+    # Initialize with direct subclasses as they are the starting point.
+    visited_for_queue = set(cls.__subclasses__())
+
+    while queue:
+        current_sub = queue.popleft()
+        all_descendants.add(current_sub)
+
+        for grandchild in current_sub.__subclasses__():
+            if grandchild not in visited_for_queue:
+                visited_for_queue.add(grandchild)
+                queue.append(grandchild)
 
-    return subclasses.union(set(cls.__subclasses__()).union(
-        [s for c in cls.__subclasses__() for s in all_subclasses(c)]))
+    return filtered_subclasses.union(all_descendants)
 
 
 type_converter = {
@@ -76,6 +105,5 @@ def item_as_dict(item):
 
 def items_as_dict_list(ls):
     return [
-        {c.name: getattr(item, c.name) for c in item.__table__.columns}
-        for item in ls
-    ]
+        {c.name: getattr(item, c.name) for c in item.__table__.columns} for item in ls
+    ]

cornflow/shared/validators.py

@@ -1,12 +1,12 @@
 """
 This file has several validators
 """
+
 import re
 from typing import Tuple, Union
 
 from jsonschema import Draft7Validator, validators
 from disposable_email_domains import blocklist
-from jsonschema.protocols import Validator
 
 
 def is_special_character(character):

cornflow/tests/const.py

@@ -17,6 +17,7 @@ INSTANCE_GC_20 = _get_file("./data/gc_20_7.json")
 INSTANCE_FILE_FAIL = _get_file("./unit/test_instances.py")
 
 EXECUTION_PATH = _get_file("./data/new_execution.json")
+CUSTOM_CONFIG_PATH = _get_file("./data/new_execution_custom_config.json")
 BAD_EXECUTION_PATH = _get_file("./data/bad_execution.json")
 EXECUTION_SOLUTION_PATH = _get_file("./data/new_execution_solution.json")
 EXECUTIONS_LIST = [EXECUTION_PATH, _get_file("./data/new_execution_2.json")]

cornflow/tests/custom_test_case.py

@@ -635,9 +635,9 @@ class BaseTestCases:
             # (we patch the request to airflow to check if the schema is valid)
             # we create 4 instances
             data_many = [self.payload for _ in range(4)]
-            data_many[-1] = {**data_many[-1], **dict(schema="timer")}
-            allrows = self.get_rows(self.url, data_many)
-            self.apply_filter(self.url, dict(schema="timer"), allrows.json[:1])
+
+            self.get_rows(self.url, data_many)
+            self.apply_filter(self.url, dict(schema="timer"), [])
 
         def test_opt_filters_date_lte(self):
             """
@@ -1117,7 +1117,7 @@ class LoginTestCases:
 
             self.assertEqual(400, response.status_code)
             self.assertEqual(
-                "Invalid token issuer. Token must be issued by a valid provider",
+                "Invalid token format or signature",
                 response.json["error"],
             )
 

cornflow/tests/unit/test_alarms.py

@@ -91,7 +91,6 @@ class TestAlarmsEndpoint(CustomTestCase):
 class TestAlarmsDetailEndpoint(TestAlarmsEndpoint, BaseTestCases.DetailEndpoint):
     def setUp(self):
         super().setUp()
-        self.url = self.url
         self.idx = 0
         self.payload = {
             "name": "Alarm 1",
@@ -138,4 +137,4 @@ class TestAlarmsDetailEndpoint(TestAlarmsEndpoint, BaseTestCases.DetailEndpoint)
                 # We check deleted at has a value
                 self.assertIsNotNone(row.deleted_at)
             else:
-                self.assertIsNone(row.deleted_at)
+                self.assertIsNone(row.deleted_at)

cornflow/tests/unit/test_cases.py

@@ -42,6 +42,7 @@ import zlib
 
 # Import from internal modules
 from cornflow.models import CaseModel, ExecutionModel, InstanceModel, UserModel
+from cornflow.shared.const import DATA_DOES_NOT_EXIST_MSG
 from cornflow.shared.utils import hash_json_256
 from cornflow.tests.const import (
     INSTANCE_URL,
@@ -227,12 +228,8 @@ class TestCasesFromInstanceExecutionEndpoint(CustomTestCase):
             "execution_id": execution_id,
             "schema": "solve_model_dag",
         }
-        self.instance = InstanceModel.get_one_object(
-            user=self.user, idx=instance_id
-        )
-        self.execution = ExecutionModel.get_one_object(
-            user=self.user, idx=execution_id
-        )
+        self.instance = InstanceModel.get_one_object(user=self.user, idx=instance_id)
+        self.execution = ExecutionModel.get_one_object(user=self.user, idx=execution_id)
 
     def test_new_case_execution(self):
         """
@@ -729,7 +726,7 @@ class TestCaseToInstanceEndpoint(CustomTestCase):
             headers=self.get_header_with_auth(self.token),
         )
         self.assertEqual(response.status_code, 404)
-        self.assertEqual(response.json["error"], "The object does not exist")
+        self.assertEqual(response.json["error"], DATA_DOES_NOT_EXIST_MSG)
 
 
 class TestCaseJsonPatch(CustomTestCase):

cornflow/tests/unit/test_executions.py

@@ -18,6 +18,7 @@ from cornflow.tests.const import (
     DAG_URL,
     BAD_EXECUTION_PATH,
     EXECUTION_SOLUTION_PATH,
+    CUSTOM_CONFIG_PATH,
 )
 from cornflow.tests.custom_test_case import CustomTestCase, BaseTestCases
 from cornflow.tests.unit.tools import patch_af_client
@@ -43,6 +44,7 @@ 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.custom_config_payload = load_file_fk(CUSTOM_CONFIG_PATH)
         self.keys_to_check = [
             "data_hash",
             "created_at",
@@ -57,11 +59,25 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
             "instance_id",
             "name",
             "indicators",
+            "username",
+            "updated_at"
         ]
 
     def test_new_execution(self):
         self.create_new_row(self.url, self.model, payload=self.payload)
 
+    def test_get_custom_config(self):
+        id = self.create_new_row(
+            self.url, self.model, payload=self.custom_config_payload
+        )
+        url = EXECUTION_URL + "/" + str(id) + "/" + "?run=0"
+
+        response = self.get_one_row(
+            url,
+            payload={**self.custom_config_payload, **dict(id=id)},
+        )
+        self.assertEqual(response["config"]["block_model"]["solver"], "mip.gurobi")
+
     @patch("cornflow.endpoints.execution.Airflow")
     def test_new_execution_run(self, af_client_class):
         patch_af_client(af_client_class)
@@ -260,6 +276,8 @@ class TestExecutionsDetailEndpointMock(CustomTestCase):
             "schema",
             "user_id",
             "indicators",
+            "username",
+            "updated_at"
         }
         # we only check the following because this endpoint does not return data
         self.items_to_check = ["name", "description"]
@@ -274,7 +292,6 @@ class TestExecutionsDetailEndpoint(
 ):
     def setUp(self):
         super().setUp()
-        self.url = self.url
         self.query_arguments = {"run": 0}
 
     # TODO: this test should be moved as it is not using the detail endpoint
@@ -303,6 +320,8 @@ class TestExecutionsDetailEndpoint(
             "name",
             "created_at",
             "state",
+            "username",
+            "updated_at"
         ]
         execution = self.get_one_row(
             self.url + idx,
@@ -450,6 +469,8 @@ class TestExecutionsLogEndpoint(TestExecutionsDetailEndpointMock):
             "user_id",
             "config",
             "indicators",
+            "username",
+            "updated_at"
         ]
 
     def test_get_one_execution(self):