cornflow 1.0.7__tar.gz → 1.0.8a1__tar.gz

{cornflow-1.0.7/cornflow.egg-info → cornflow-1.0.8a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: cornflow
-Version: 1.0.7
+Version: 1.0.8a1
 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
@@ -48,19 +48,33 @@ Description: Cornflow
         Installation instructions
         -------------------------------
         
-        Cornflow is tested with Ubuntu 20.04, python >= 3.5 and git.
+        Cornflow is tested with Ubuntu 20.04, python >= 3.8 and git.
         
         Download the Cornflow project and install requirements::
         
-            git clone git@github.com:baobabsoluciones/cornflow.git
-            cd cornflow-server
             python3 -m venv venv
-            venv/bin/pip3 install -r requirements-dev.txt
+            venv/bin/pip3 install cornflow
+        
+        initialize the sqlite database::
+        
+            source venv/bin/activate
+            export FLASK_APP=cornflow.app
+            export DATABASE_URL=sqlite:///cornflow.db
+            flask db upgrade
+            flask access_init
+            flask create_service_user  -u airflow -e airflow_test@admin.com -p airflow_test_password
+            flask create_admin_user  -u cornflow -e cornflow_admin@admin.com -p cornflow_admin_password
+        
         
         activate the virtual environment and run Cornflow::
         
             source venv/bin/activate
             export FLASK_APP=cornflow.app
+            export SECRET_KEY=THISNEEDSTOBECHANGED
+            export DATABASE_URL=sqlite:///cornflow.db
+            export AIRFLOW_URL=http://127.0.0.1:8080/
+            export AIRFLOW_USER=airflow_user
+            export AIRFLOW_PWD=airflow_pwd
             flask run
         
         **Cornflow needs a running installation of Airflow to operate and more configuration**. Check `the installation docs <https://baobabsoluciones.github.io/cornflow/main/install.html>`_ for more details on installing airflow, configuring the application and initializing the database.
@@ -143,8 +157,7 @@ Description: Cornflow
         
         To deploy a cornflow solution method, the following tasks need to be accomplished:
         
-        #. Create I/O schemas for the new problem (e.g., “TSP format”).
-        #. Create a solve function (e.g., a 2-opt heuristic).
+        #. Create an Application for the new problem
         #. Do a PR to a compatible repo linked to a server instance (e.g., like `this one <https://github.com/baobabsoluciones/cornflow>`_).
         
         For more details on each part, check the `deployment guide <https://baobabsoluciones.github.io/cornflow/guides/deploy_solver.html>`_.

{cornflow-1.0.7 → cornflow-1.0.8a1}/README.rst

@@ -40,19 +40,33 @@ Cornflow helps you formalize your problem by proposing development guidelines. I
 Installation instructions
 -------------------------------
 
-Cornflow is tested with Ubuntu 20.04, python >= 3.5 and git.
+Cornflow is tested with Ubuntu 20.04, python >= 3.8 and git.
 
 Download the Cornflow project and install requirements::
 
-    git clone git@github.com:baobabsoluciones/cornflow.git
-    cd cornflow-server
     python3 -m venv venv
-    venv/bin/pip3 install -r requirements-dev.txt
+    venv/bin/pip3 install cornflow
+
+initialize the sqlite database::
+
+    source venv/bin/activate
+    export FLASK_APP=cornflow.app
+    export DATABASE_URL=sqlite:///cornflow.db
+    flask db upgrade
+    flask access_init
+    flask create_service_user  -u airflow -e airflow_test@admin.com -p airflow_test_password
+    flask create_admin_user  -u cornflow -e cornflow_admin@admin.com -p cornflow_admin_password
+
 
 activate the virtual environment and run Cornflow::
 
     source venv/bin/activate
     export FLASK_APP=cornflow.app
+    export SECRET_KEY=THISNEEDSTOBECHANGED
+    export DATABASE_URL=sqlite:///cornflow.db
+    export AIRFLOW_URL=http://127.0.0.1:8080/
+    export AIRFLOW_USER=airflow_user
+    export AIRFLOW_PWD=airflow_pwd
     flask run
 
 **Cornflow needs a running installation of Airflow to operate and more configuration**. Check `the installation docs <https://baobabsoluciones.github.io/cornflow/main/install.html>`_ for more details on installing airflow, configuring the application and initializing the database.
@@ -135,8 +149,7 @@ Using cornflow to deploy a solution method
 
 To deploy a cornflow solution method, the following tasks need to be accomplished:
 
-#. Create I/O schemas for the new problem (e.g., “TSP format”).
-#. Create a solve function (e.g., a 2-opt heuristic).
+#. Create an Application for the new problem
 #. Do a PR to a compatible repo linked to a server instance (e.g., like `this one <https://github.com/baobabsoluciones/cornflow>`_).
 
 For more details on each part, check the `deployment guide <https://baobabsoluciones.github.io/cornflow/guides/deploy_solver.html>`_.

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/cli/schemas.py

@@ -25,7 +25,7 @@ def schemas():
 
 @schemas.command(
     name="generate_from_schema",
-    help="Command to generate models, endpoints and schemas from a jsonschema"
+    help="Command to generate models, endpoints and schemas from a jsonschema",
 )
 @click.option(
     "--path", "-p", type=str, help="The absolute path to the JSONSchema", required=True
@@ -70,7 +70,13 @@ def schemas():
     required=False,
 )
 def generate_from_schema(
-    path, app_name, output_path, remove_methods, one, endpoints_methods, endpoints_access
+    path,
+    app_name,
+    output_path,
+    remove_methods,
+    one,
+    endpoints_methods,
+    endpoints_access,
 ):
     """
     This method is executed for the command and creates all the files for the REST API from the provided JSONSchema
@@ -126,59 +132,64 @@ def generate_from_schema(
         output_path=output_path,
         options=methods_to_add,
         name_table=name_table,
-        endpoints_access=dict_endpoints_access
+        endpoints_access=dict_endpoints_access,
     ).main()
 
 
-@schemas.command(name="schema_from_models", help="Command to generate a jsonschema from a set of models")
-@click.option(
-    "--path",
-    "-p",
-    type=str,
-    help="The absolute path to folder containing the models",
-    required=True,
-)
-@click.option("--output-path", "-o", type=str, help="The output path", required=False)
-@click.option(
-    "--ignore-files",
-    "-i",
-    type=str,
-    help="Files that will be ignored (with the .py extension). "
-    "__init__.py files are automatically ignored. Ex: 'instance.py'",
-    multiple=True,
-    required=False,
-)
-@click.option(
-    "--leave-bases/--no-leave-bases",
-    "-l/-nl",
-    default=False,
-    help="Use this option to leave the bases classes BaseDataModel, "
-    "EmptyModel and TraceAttributes in the schema. By default, they will be deleted",
-)
-def schema_from_models(path, output_path, ignore_files, leave_bases):
-    """
-
-    :param str path: the path to the folder that contains the models
-    :param output_path: the output path where the JSONSchema should be placed
-    :param str ignore_files: files to be ignored.
-    :param str leave_bases: if the JSONSchema should have abstract classes used as the base for other clases.
-    :return: a click status code
-    :rtype: int
-    """
-    path = path.replace("\\", "/")
-    output = None
-    if output_path:
-        output = output_path.replace("\\", "/")
-
-    if ignore_files:
-        ignore_files = list(ignore_files)
-
-    click.echo("Generating JSONSchema file from the REST API")
-    click.echo(f"The path to the JSONSchema is {path}")
-    click.echo(f"The output_path is {output}")
-    click.echo(f"The ignore_files is {ignore_files}")
-    click.echo(f"The leave_bases is {leave_bases}")
-
-    SchemaGenerator(
-        path, output_path=output, ignore_files=ignore_files, leave_bases=leave_bases
-    ).main()
+# @schemas.command(
+#     name="schema_from_models",
+#     help="Command to generate a jsonschema from a set of models",
+# )
+# @click.option(
+#     "--path",
+#     "-p",
+#     type=str,
+#     help="The absolute path to folder containing the models",
+#     required=True,
+# )
+# @click.option("--output-path", "-o", type=str, help="The output path", required=False)
+# @click.option(
+#     "--ignore-files",
+#     "-i",
+#     type=str,
+#     help="Files that will be ignored (with the .py extension). "
+#     "__init__.py files are automatically ignored. Ex: 'instance.py'",
+#     multiple=True,
+#     required=False,
+# )
+# @click.option(
+#     "--leave-bases/--no-leave-bases",
+#     "-l/-nl",
+#     default=False,
+#     help="Use this option to leave the bases classes BaseDataModel, "
+#     "EmptyModel and TraceAttributes in the schema. By default, they will be deleted",
+# )
+# def schema_from_models(path, output_path, ignore_files, leave_bases):
+#     """
+#
+#     :param str path: the path to the folder that contains the models
+#     :param output_path: the output path where the JSONSchema should be placed
+#     :param str ignore_files: files to be ignored.
+#     :param str leave_bases: if the JSONSchema should have abstract classes used as the base for other clases.
+#     :return: a click status code
+#     :rtype: int
+#     """
+#     path = path.replace("\\", "/")
+#     output = None
+#     if output_path:
+#         output = output_path.replace("\\", "/")
+#
+#     if ignore_files:
+#         ignore_files = list(ignore_files)
+#
+#     click.echo("Generating JSONSchema file from the REST API")
+#     click.echo(f"The path to the JSONSchema is {path}")
+#     click.echo(f"The output_path is {output}")
+#     click.echo(f"The ignore_files is {ignore_files}")
+#     click.echo(f"The leave_bases is {leave_bases}")
+#
+#     SchemaGenerator(
+#         path, output_path=output, ignore_files=ignore_files, leave_bases=leave_bases
+#     ).main()
+#
+#     return True

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/cli/tools/schema_generator.py

@@ -6,6 +6,8 @@ import json
 import importlib.util
 from distutils.dir_util import copy_tree
 from unittest.mock import MagicMock
+
+import click
 from flask_sqlalchemy import SQLAlchemy
 import shutil
 from pytups import TupList, SuperDict
@@ -15,7 +17,6 @@ from sqlalchemy.sql.sqltypes import Integer
 
 class SchemaGenerator:
     def __init__(self, path, output_path=None, ignore_files=None, leave_bases=False):
-
         self.path = path
         self.tmp_path = os.path.join(os.getcwd(), "tmp_files")
         self.output_path = output_path or "./output_schema.json"
@@ -76,7 +77,6 @@ class SchemaGenerator:
         db = SQLAlchemy()
         try:
             for file_path, file_name in files:
-
                 spec = importlib.util.spec_from_file_location(file_name, file_path)
                 mod = importlib.util.module_from_spec(spec)
 
@@ -142,7 +142,7 @@ class SchemaGenerator:
 
             db.session.close()
         except Exception as err:
-            print(err)
+            click.echo(err)
 
     def inherit(self):
         all_classes = set(self.parents.keys())

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/endpoints/execution.py

@@ -39,7 +39,11 @@ from cornflow.shared.const import (
     EXEC_STATE_QUEUED,
 )
 from cornflow.shared.exceptions import AirflowError, ObjectDoesNotExist, InvalidData
-from cornflow.shared.validators import json_schema_validate_as_string
+from cornflow.shared.validators import (
+    json_schema_validate_as_string,
+    json_schema_extend_and_validate_as_string,
+)
+
 
 class ExecutionEndpoint(BaseMetaResource):
     """
@@ -76,12 +80,10 @@ class ExecutionEndpoint(BaseMetaResource):
         ]
 
         running_executions = [
-            execution for execution in executions
-            if execution.state in [
-                EXEC_STATE_RUNNING,
-                EXEC_STATE_QUEUED,
-                EXEC_STATE_UNKNOWN
-            ]
+            execution
+            for execution in executions
+            if execution.state
+            in [EXEC_STATE_RUNNING, EXEC_STATE_QUEUED, EXEC_STATE_UNKNOWN]
         ]
 
         for execution in running_executions:
@@ -146,14 +148,6 @@ class ExecutionEndpoint(BaseMetaResource):
             user=self.get_user(), idx=execution.instance_id
         )
 
-        if instance is None:
-            err = "The instance to solve does not exist"
-            raise ObjectDoesNotExist(
-                error=err,
-                log_txt=f"Error while user {self.get_user()} tries to create an execution "
-                f"for instance {execution.instance_id}. " + err,
-            )
-
         current_app.logger.debug(f"The request is: {request.args.get('run')}")
         # this allows testing without airflow interaction:
         if request.args.get("run", "1") == "0":
@@ -184,7 +178,9 @@ class ExecutionEndpoint(BaseMetaResource):
 
         # Validate config before running the dag
         config_schema = DeployedDAG.get_one_schema(config, schema, CONFIG_SCHEMA)
-        config_errors = json_schema_validate_as_string(config_schema, kwargs["config"])
+        new_config, config_errors = json_schema_extend_and_validate_as_string(
+            config_schema, kwargs["config"]
+        )
         if config_errors:
             execution.update_state(
                 EXEC_STATE_ERROR_START,
@@ -197,6 +193,8 @@ class ExecutionEndpoint(BaseMetaResource):
                 log_txt=f"Error while user {self.get_user()} tries to create an execution. "
                 f"Configuration data does not match the jsonschema.",
             )
+        elif new_config != kwargs["config"]:
+            execution.update_config(new_config)
 
         # Validate instance data before running the dag
         instance_schema = DeployedDAG.get_one_schema(config, schema, INSTANCE_SCHEMA)
@@ -326,7 +324,9 @@ class ExecutionRelaunchEndpoint(BaseMetaResource):
             }, 201
 
         # Validate config before running the dag
-        config_schema = DeployedDAG.get_one_schema(config, kwargs["schema"], CONFIG_SCHEMA)
+        config_schema = DeployedDAG.get_one_schema(
+            config, kwargs["schema"], CONFIG_SCHEMA
+        )
         config_errors = json_schema_validate_as_string(config_schema, kwargs["config"])
         if config_errors:
             raise InvalidData(
@@ -444,14 +444,18 @@ class ExecutionDetailsEndpoint(ExecutionDetailsEndpointBase):
         schema = ExecutionModel.get_one_object(user=self.get_user(), idx=idx).schema
 
         if data.get("data") is not None and schema is not None:
-            data_jsonschema = DeployedDAG.get_one_schema(config, schema, SOLUTION_SCHEMA)
-            validation_errors = json_schema_validate_as_string(data_jsonschema, data["data"])
+            data_jsonschema = DeployedDAG.get_one_schema(
+                config, schema, SOLUTION_SCHEMA
+            )
+            validation_errors = json_schema_validate_as_string(
+                data_jsonschema, data["data"]
+            )
 
             if validation_errors:
                 raise InvalidData(
                     payload=dict(jsonschema_errors=validation_errors),
                     log_txt=f"Error while user {self.get_user()} tries to edit execution {idx}. "
-                            f"Solution data does not match the jsonschema.",
+                    f"Solution data does not match the jsonschema.",
                 )
 
         current_app.logger.info(f"User {self.get_user()} edits execution {idx}")

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/models/dag.py

@@ -71,7 +71,8 @@ class DeployedDAG(TraceAttributesModel):
             jsonschema = item.instance_checks_schema
         elif schema == SOLUTION_CHECKS_SCHEMA:
             jsonschema = item.solution_checks_schema
-        else:           # schema == CONFIG_SCHEMA
+        # schema == CONFIG_SCHEMA
+        else:
             jsonschema = item.config_schema
 
         if jsonschema is None:

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/models/execution.py

@@ -99,6 +99,16 @@ class ExecutionModel(BaseDataModel):
             self.checks = None
         super().update(data)
 
+    def update_config(self, config: dict):
+        """
+        Method to update the config of the execution after extending with default values
+
+        :param dict config: The config to store
+        :return: nothing
+        """
+        self.config = config
+        super().update({})
+
     def update_state(self, code, message=None):
         """
         Method to update the state code and message of an execution

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/shared/validators.py

@@ -4,8 +4,9 @@ This file has several validators
 import re
 from typing import Tuple, Union
 
-from jsonschema import Draft7Validator
+from jsonschema import Draft7Validator, validators
 from disposable_email_domains import blocklist
+from jsonschema.protocols import Validator
 
 
 def is_special_character(character):
@@ -66,6 +67,27 @@ def check_email_pattern(email: str) -> Tuple[bool, Union[str, None]]:
     return True, None
 
 
+def extend_with_default(validator_class):
+    """
+    Method to extend a validator, so it extends the data with the default values defined on the jsonschema
+    """
+    validate_properties = validator_class.VALIDATORS["properties"]
+
+    def set_defaults(validator, properties, instance, schema):
+        for prop, sub in properties.items():
+            if "default" in sub:
+                instance.setdefault(prop, sub["default"])
+        for error in validate_properties(
+            validator,
+            properties,
+            instance,
+            schema,
+        ):
+            yield error
+
+    return validators.extend(validator_class, {"properties": set_defaults})
+
+
 def json_schema_validate(schema: dict, data: dict) -> list:
     """
     Method to validate some data against a json schema
@@ -81,6 +103,23 @@ def json_schema_validate(schema: dict, data: dict) -> list:
     return []
 
 
+def json_schema_extend_and_validate(schema: dict, data: dict) -> Tuple[dict, list]:
+    """
+    Method to validate som data, extend it with default values and give back the processed errors
+
+    :param dict schema: the json schema in dict format.
+    :param dict data: the data to validate in dict format
+    :return: a tuple with the data extended and the errors found
+    :rtype: tuple
+    """
+    data_cp = dict(data)
+    default_validator = extend_with_default(Draft7Validator)
+    validator = default_validator(schema)
+    if not validator.is_valid(data_cp):
+        return data_cp, [e for e in validator.iter_errors(data_cp)]
+    return data_cp, []
+
+
 def json_schema_validate_as_string(schema: dict, data: dict) -> list:
     """
     Method to validate some data against a json schema
@@ -91,3 +130,18 @@ def json_schema_validate_as_string(schema: dict, data: dict) -> list:
     :rtype: list
     """
     return [str(e) for e in json_schema_validate(schema, data)]
+
+
+def json_schema_extend_and_validate_as_string(
+    schema: dict, data: dict
+) -> Tuple[dict, list]:
+    """
+    Method to extend the schema with default values and give back the processed error
+
+    :param dict schema: the json schema in dict format.
+    :param dict data: the data to validate in dict format
+    :return: a tuple with the data extended and the errors found
+    :rtype: tuple
+    """
+    data_cp, errors = json_schema_extend_and_validate(schema, data)
+    return data_cp, [str(e) for e in errors]

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/tests/const.py

@@ -16,6 +16,8 @@ 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")
+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")]
 EXECUTION_URL = PREFIX + "/execution/"
 EXECUTION_URL_NORUN = EXECUTION_URL + "?run=0"
@@ -63,6 +65,8 @@ TABLES_URL = PREFIX + "/table/"
 ALARMS_URL = PREFIX + "/alarms/"
 MAIN_ALARMS_URL = PREFIX + "/main-alarms/"
 
+LICENSES_URL = PREFIX + "/licences/"
+
 PUBLIC_DAGS = [
     "solve_model_dag",
     "gc",

{cornflow-1.0.7 → cornflow-1.0.8a1}/cornflow/tests/unit/test_executions.py

@@ -16,6 +16,8 @@ from cornflow.tests.const import (
     EXECUTION_URL_NORUN,
     INSTANCE_URL,
     DAG_URL,
+    BAD_EXECUTION_PATH,
+    EXECUTION_SOLUTION_PATH,
 )
 from cornflow.tests.custom_test_case import CustomTestCase, BaseTestCases
 from cornflow.tests.unit.tools import patch_af_client
@@ -38,7 +40,9 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
             return temp
 
         self.payload = load_file_fk(EXECUTION_PATH)
+        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)
 
     def test_new_execution(self):
         self.create_new_row(self.url, self.model, payload=self.payload)
@@ -49,6 +53,55 @@ class TestExecutionsListEndpoint(BaseTestCases.ListFilters):
 
         self.create_new_row(EXECUTION_URL, self.model, payload=self.payload)
 
+    @patch("cornflow.endpoints.execution.Airflow")
+    def test_new_execution_bad_config(self, af_client_class):
+        patch_af_client(af_client_class)
+        response = self.create_new_row(
+            EXECUTION_URL,
+            self.model,
+            payload=self.bad_payload,
+            expected_status=400,
+            check_payload=False,
+        )
+        self.assertIn("error", response)
+        self.assertIn("jsonschema_errors", response)
+
+    @patch("cornflow.endpoints.execution.Airflow")
+    def test_new_execution_partial_config(self, af_client_class):
+        patch_af_client(af_client_class)
+        self.payload["config"].pop("solver")
+        response = self.create_new_row(
+            EXECUTION_URL, self.model, payload=self.payload, check_payload=False
+        )
+        self.assertIn("solver", response["config"])
+        self.assertEqual(response["config"]["solver"], "cbc")
+
+    @patch("cornflow.endpoints.execution.Airflow")
+    def test_new_execution_with_solution(self, af_client_class):
+        patch_af_client(af_client_class)
+        self.payload["data"] = self.solution
+        response = self.create_new_row(
+            EXECUTION_URL,
+            self.model,
+            payload=self.payload,
+            check_payload=False,
+        )
+
+    @patch("cornflow.endpoints.execution.Airflow")
+    def test_new_execution_with_solution_bad(self, af_client_class):
+        patch_af_client(af_client_class)
+        patch_af_client(af_client_class)
+        self.payload["data"] = {"message": "THIS IS NOT A VALID SOLUTION"}
+        response = self.create_new_row(
+            EXECUTION_URL,
+            self.model,
+            payload=self.payload,
+            check_payload=False,
+            expected_status=400,
+        )
+        self.assertIn("error", response)
+        self.assertIn("jsonschema_errors", response)
+
     def test_new_execution_no_instance(self):
         payload = dict(self.payload)
         payload["instance_id"] = "bad_id"
@@ -281,11 +334,7 @@ class TestExecutionsDetailEndpoint(
     def test_stop_execution(self, af_client_class):
         patch_af_client(af_client_class)
 
-        idx = self.create_new_row(
-            EXECUTION_URL,
-            self.model,
-            payload=self.payload
-        )
+        idx = self.create_new_row(EXECUTION_URL, self.model, payload=self.payload)
 
         response = self.client.post(
             self.url + str(idx) + "/",
@@ -347,11 +396,13 @@ class TestExecutionsStatusEndpoint(TestExecutionsDetailEndpointMock):
     @patch("cornflow.endpoints.execution.Airflow")
     def test_get_one_status(self, af_client_class):
         patch_af_client(af_client_class)
-    
+
         idx = self.create_new_row(EXECUTION_URL, self.model, self.payload)
         payload = dict(self.payload)
         payload["id"] = idx
-        data = self.get_one_row(EXECUTION_URL + idx + "/status/", payload, check_payload=False)
+        data = self.get_one_row(
+            EXECUTION_URL + idx + "/status/", payload, check_payload=False
+        )
         self.assertEqual(data["state"], 1)
 
     @patch("cornflow.endpoints.execution.Airflow")

cornflow-1.0.8a1/cornflow/tests/unit/test_licenses.py

@@ -0,0 +1,45 @@
+from cornflow.endpoints import LicensesEndpoint
+from cornflow.tests.const import LICENSES_URL, _get_file
+from cornflow.tests.custom_test_case import CustomTestCase
+
+
+class TestLicensesListEndpoint(CustomTestCase):
+    @staticmethod
+    def read_requirements():
+        with open(_get_file("../../requirements.txt")) as req:
+            content = req.read()
+            requirements = content.split("\n")
+
+        requirements = [
+            r.split("=")[0].split(">")[0].split("<")[0].lower()
+            for r in requirements
+            if r != ""
+        ]
+        return requirements
+
+    def setUp(self):
+        super().setUp()
+        self.roles_with_access = LicensesEndpoint.ROLES_WITH_ACCESS
+        self.libraries = self.read_requirements()
+
+    def tearDown(self):
+        super().tearDown()
+
+    def test_get_licenses(self):
+        for role in self.roles_with_access:
+            self.token = self.create_user_with_role(role)
+            response = self.client.get(
+                LICENSES_URL,
+                follow_redirects=True,
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": "Bearer " + self.token,
+                },
+            )
+
+            self.assertEqual(200, response.status_code)
+            self.assertIsInstance(response.json, list)
+            libraries = [k["library"].lower() for k in response.json]
+
+            for lib in self.libraries:
+                self.assertIn(lib, libraries)