Tests/db backend tests #370

datagateway_api/src/datagateway_api/database/helpers.py

@@ -94,7 +94,7 @@ def commit_changes(self):
         except Exception as e:
             log.error("Error whilst committing changes to %s, rolling back", self.table)
             self.session.rollback()
-            raise e
+            raise BadRequestError(f"Bad request: {e}")
 
 
 class CountQuery(Query):

datagateway_api/src/datagateway_api/database/models.py

@@ -22,7 +22,10 @@
 from sqlalchemy.orm.collections import InstrumentedList
 
 from datagateway_api.src.common.date_handler import DateHandler
-from datagateway_api.src.common.exceptions import DatabaseError, FilterError
+from datagateway_api.src.common.exceptions import (
+    DatabaseError,
+    FilterError,
+)
 
 Base = declarative_base()
 
@@ -179,6 +182,7 @@ def update_from_dict(self, dictionary):
         """
         for key in dictionary:
             setattr(self, key, dictionary[key])
+
         return self.to_dict()
 
 

test/datagateway_api/db/conftest.py

@@ -5,6 +5,7 @@
 
 from datagateway_api.src.common.config import Config
 from datagateway_api.src.common.constants import Constants
+from datagateway_api.src.common.exceptions import MissingRecordError
 from datagateway_api.src.datagateway_api.database.helpers import (
     delete_row_by_id,
     insert_row_into_table,
@@ -15,6 +16,7 @@
     INVESTIGATION,
     INVESTIGATIONINSTRUMENT,
 )
+from test.datagateway_api.db.endpoints.test_create_db import TestDBCreateData
 
 
 def set_meta_attributes(entity):
@@ -65,8 +67,11 @@ def single_investigation_test_data_db():
     investigation = create_investigation_db_data()
 
     yield investigation
-
-    delete_row_by_id(INVESTIGATION, investigation.id)
+    try:
+        delete_row_by_id(INVESTIGATION, investigation.id)
+    except MissingRecordError as e:
+        # This should occur on DELETE endpoints, normal behaviour for those tests
+        print(e)
 
 
 @pytest.fixture()
@@ -134,3 +139,30 @@ def final_facilitycycle_id(flask_test_app_db, valid_db_credentials_header):
         headers=valid_db_credentials_header,
     )
     return final_facilitycycle_result.json["id"]
+
+
+@pytest.fixture()
+def remove_test_created_investigation_data(
+    flask_test_app_db, valid_db_credentials_header,
+):
+    yield
+
+    created_test_data = flask_test_app_db.get(
+        f"{Config.config.datagateway_api.extension}/investigations?where="
+        '{"name":{"like":'
+        f'"{TestDBCreateData.investigation_name_prefix}"'
+        "}}",
+        headers=valid_db_credentials_header,
+    )
+
+    investigation_ids = []
+
+    for investigation in created_test_data.json:
+        investigation_ids.append(investigation["id"])
+
+    for investigation_id in investigation_ids:
+        flask_test_app_db.delete(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            f"/{investigation_id}",
+            headers=valid_db_credentials_header,
+        )

test/datagateway_api/db/endpoints/test_create_db.py

@@ -0,0 +1,114 @@
+import pytest
+
+from datagateway_api.src.common.config import Config
+
+
+def prepare_db_data_for_assertion(response_json):
+    response_json.pop("createId")
+    response_json.pop("createTime")
+    response_json.pop("id")
+    response_json.pop("modId")
+    response_json.pop("modTime")
+    response_json.pop("visitId")
+
+    if response_json["releaseDate"] is None:
+        return response_json
+
+    response_json["endDate"] = response_json["endDate"][:-6]
+    response_json["startDate"] = response_json["startDate"][:-6]
+
+    if response_json["releaseDate"] is None:
+        return response_json
+    else:
+        response_json["releaseDate"] = response_json["releaseDate"][:-6]
+
+    return response_json
+
+
+class TestDBCreateData:
+    investigation_name_prefix = "DB Test Data for API Testing, Data Creation"
+
+    @pytest.mark.usefixtures("remove_test_created_investigation_data")
+    def test_valid_create_data(self, flask_test_app_db, valid_db_credentials_header):
+        create_investigations_json = [
+            {
+                "name": f"{self.investigation_name_prefix} {i}",
+                "title": "Test data for the DB Backend on DataGateway API",
+                "summary": "DB Test data for DataGateway API testing",
+                "releaseDate": "2020-03-03 08:00:08",
+                "startDate": "2020-02-02 09:00:09",
+                "endDate": "2020-02-03 10:00:10",
+                "visitId": "Data Creation Visit DB",
+                "doi": "DataGateway API DB Test DOI",
+                "facilityID": 1,
+                "typeID": 1,
+                "fileCount": 1,
+                "fileSize": 6,
+            }
+            for i in range(2)
+        ]
+
+        test_response = flask_test_app_db.post(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=create_investigations_json,
+        )
+
+        response_json = test_response.json
+
+        for investigation_request in response_json:
+            prepare_db_data_for_assertion(investigation_request)
+
+        for investigation in create_investigations_json:
+            investigation.pop("visitId")
+        assert create_investigations_json == response_json
+
+    @pytest.mark.usefixtures("remove_test_created_investigation_data")
+    def test_valid_boundary_create_data(
+        self, flask_test_app_db, valid_db_credentials_header,
+    ):
+        """Create a single investigation, as opposed to multiple"""
+
+        create_investigation_json = {
+            "name": f"{self.investigation_name_prefix} 0",
+            "title": "Test data for the DB Backend on the API",
+            "summary": "Test data for DataGateway API testing",
+            "releaseDate": "2020-03-03 08:00:08",
+            "startDate": "2020-02-02 09:00:09",
+            "endDate": "2020-02-03 10:00:10",
+            "visitId": "Data Creation Visit",
+            "doi": "DataGateway API Test DOI",
+            "facilityID": 1,
+            "typeID": 1,
+            "fileCount": 3,
+            "fileSize": 2,
+        }
+
+        test_response = flask_test_app_db.post(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=create_investigation_json,
+        )
+
+        response_json = prepare_db_data_for_assertion(test_response.json)
+
+        create_investigation_json.pop("visitId")
+
+        assert create_investigation_json == response_json
+
+    def test_invalid_create_data(
+        self, flask_test_app_db, valid_db_credentials_header,
+    ):
+        """An investigation requires a minimum of: name, visitId, facility, type"""
+
+        invalid_request_body = {
+            "title": "Test Title for DataGateway API Backend testing",
+        }
+
+        test_response = flask_test_app_db.post(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=invalid_request_body,
+        )
+
+        assert test_response.status_code == 400

test/datagateway_api/db/endpoints/test_delete_by_id_db.py

@@ -0,0 +1,40 @@
+from datagateway_api.src.common.config import Config
+
+
+class TestDeleteById:
+    def test_valid_delete_with_id(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        single_investigation_test_data_db,
+    ):
+        single_investigation_test_data = single_investigation_test_data_db.to_dict()
+
+        test_response = flask_test_app_db.delete(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            f'/{single_investigation_test_data["id"]}',
+            headers=valid_db_credentials_header,
+        )
+
+        assert test_response.status_code == 204
+
+    def test_invalid_delete_with_id(
+        self, flask_test_app_db, valid_db_credentials_header,
+    ):
+        """Request with a non-existent ID"""
+
+        final_investigation_result = flask_test_app_db.get(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            '/findone?order="id DESC"',
+            headers=valid_db_credentials_header,
+        )
+        test_data_id = final_investigation_result.json["id"]
+
+        # Adding 100 onto the ID to the most recent result should ensure a 404
+        test_response = flask_test_app_db.delete(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            f"/{test_data_id + 100}",
+            headers=valid_db_credentials_header,
+        )
+
+        assert test_response.status_code == 404

test/datagateway_api/db/endpoints/test_update_by_id_db.py

@@ -0,0 +1,66 @@
+from datagateway_api.src.common.config import Config
+
+
+class TestUpdateByID:
+    def test_valid_update_with_id(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        single_investigation_test_data_db,
+    ):
+        update_data_json = {
+            "doi": "DB Test Data Identifier",
+            "summary": "DB Test Summary",
+            "startDate": "2019-01-04 01:01:01",
+        }
+
+        single_investigation_test_data = single_investigation_test_data_db.to_dict()
+
+        single_investigation_test_data.update(update_data_json)
+        test_response = flask_test_app_db.patch(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            f"/{single_investigation_test_data['id']}",
+            headers=valid_db_credentials_header,
+            json=update_data_json,
+        )
+
+        response_json = test_response.json
+
+        # The DB returns times with timezone indicators,
+        # but does not accept them being created.
+        # This strips the timezone indicators out so that the results can be compared.
+        response_json["startDate"] = response_json["startDate"][:-6]
+
+        assert response_json == single_investigation_test_data
+
+    def test_invalid_update_with_id(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        single_investigation_test_data_db,
+    ):
+        """This test will attempt to put the DB in an invalid state"""
+
+        invalid_update_json = {
+            "doi": "_" * 300,
+        }
+
+        single_investigation_test_data = single_investigation_test_data_db.to_dict()
+
+        test_response = flask_test_app_db.patch(
+            f"{Config.config.datagateway_api.extension}/investigations"
+            f"/{single_investigation_test_data['id']}",
+            headers=valid_db_credentials_header,
+            json=invalid_update_json,
+        )
+
+        print(
+            "If this test is failing "
+            "you may need to set sql_mode to "
+            "STRICT_ALL_TABLES",
+        )
+
+        # If this test is failing
+        # you may need to set sql_mode to
+        # STRICT_ALL_TABLES
+        assert test_response.status_code == 400

test/datagateway_api/db/endpoints/test_update_multiple_db.py

@@ -0,0 +1,85 @@
+from datagateway_api.src.common.config import Config
+
+
+class TestUpdateMultipleEntities:
+    def test_valid_multiple_update_data(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        multiple_investigation_test_data_db,
+    ):
+        expected_doi = "DB Test Data Identifier"
+        expected_summary = "DB Test summary"
+
+        update_data_list = []
+        test_data_list = []
+
+        for investigation_object in multiple_investigation_test_data_db:
+            investigation = investigation_object.to_dict()
+            investigation["doi"] = expected_doi
+            investigation["summary"] = expected_summary
+
+            update_entity = {
+                "id": investigation["id"],
+                "doi": expected_doi,
+                "summary": expected_summary,
+            }
+            update_data_list.append(update_entity)
+            test_data_list.append(investigation)
+
+        test_response = flask_test_app_db.patch(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=update_data_list,
+        )
+
+        assert test_response.json == test_data_list
+
+    def test_valid_boundary_update_data(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        single_investigation_test_data_db,
+    ):
+        """ Request body is a dictionary, not a list of dictionaries"""
+
+        expected_doi = "Test Data Identifier"
+        expected_summary = "Test Summary"
+        single_investigation_test_data = single_investigation_test_data_db.to_dict()
+
+        update_data_json = {
+            "id": single_investigation_test_data["id"],
+            "doi": expected_doi,
+            "summary": expected_summary,
+        }
+        single_investigation_test_data["doi"] = expected_doi
+        single_investigation_test_data["summary"] = expected_summary
+
+        test_response = flask_test_app_db.patch(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=update_data_json,
+        )
+
+        assert test_response.json == [single_investigation_test_data]
+
+    def test_invalid_missing_update_data(
+        self,
+        flask_test_app_db,
+        valid_db_credentials_header,
+        single_investigation_test_data_db,
+    ):
+        """There should be an ID in the request body to know which entity to update"""
+
+        update_data_json = {
+            "doi": "Test Data Identifier",
+            "summary": "Test Summary",
+        }
+
+        test_response = flask_test_app_db.patch(
+            f"{Config.config.datagateway_api.extension}/investigations",
+            headers=valid_db_credentials_header,
+            json=update_data_json,
+        )
+
+        assert test_response.status_code == 400