Greatly raised coverage for user & discovery service

dbrepo-discovery-service/rest-service/src/main/java/at/tuwien/config/GatewayConfig.java

+package at.tuwien.config;
+
+import lombok.Getter;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.support.BasicAuthenticationInterceptor;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.DefaultUriBuilderFactory;
+
+@Getter
+@Configuration
+public class GatewayConfig {
+
+    @Value("${fda.gateway.endpoint}")
+    private String gatewayEndpoint;
+
+    @Value("${spring.rabbitmq.username}")
+    private String brokerUsername;
+
+    @Value("${spring.rabbitmq.password}")
+    private String brokerPassword;
+
+    @Bean("brokerRestTemplate")
+    public RestTemplate brokerRestTemplate() {
+        final RestTemplate restTemplate = new RestTemplate();
+        restTemplate.setUriTemplateHandler(new DefaultUriBuilderFactory(gatewayEndpoint));
+        restTemplate.getInterceptors()
+                .add(new BasicAuthenticationInterceptor(brokerUsername, brokerPassword));
+        return restTemplate;
+    }
+}

dbrepo-discovery-service/rest-service/src/main/java/at/tuwien/service/JacksonConfig.java → dbrepo-discovery-service/rest-service/src/main/java/at/tuwien/config/JacksonConfig.java

-package at.tuwien.service;
+package at.tuwien.config;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;

dbrepo-discovery-service/rest-service/src/main/java/at/tuwien/service/ReadyConfig.java → dbrepo-discovery-service/rest-service/src/main/java/at/tuwien/config/ReadyConfig.java

-package at.tuwien.service;
+package at.tuwien.config;
 
 import com.google.common.io.Files;
 import org.springframework.beans.factory.annotation.Value;

dbrepo-discovery-service/rest-service/src/main/resources/application-docker.yml

-app.version: '@project.version@'
-spring:
-  main.banner-mode: off
-  datasource:
-    url: jdbc:mariadb://metadata-db:3306/fda
-    driver-class-name: org.mariadb.jdbc.Driver
-    username: "${METADATA_USERNAME}"
-    password: "${METADATA_PASSWORD}"
-  jpa:
-    show-sql: false
-    database-platform: org.hibernate.dialect.MariaDBDialect
-    hibernate:
-      ddl-auto: validate
-      use-new-id-generator-mappings: false
-    open-in-view: false
-    properties:
-      hibernate:
-        default_schema: fda
-        jdbc:
-          time_zone: UTC
-  application:
-    name: discovery-service
-  cloud:
-    loadbalancer.ribbon.enabled: false
-management.endpoints.web.exposure.include: health,info,prometheus
-server.port: 9090
-logging:
-  pattern.console: "%d %highlight(%-5level) %msg%n"
-  level:
-    root: warn
-    at.tuwien.: "${LOG_LEVEL}"
-    org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver: debug
-eureka:
-  eureka.client.register-with-eureka: false
-  eureka.client.fetch-registry: false
-  instance.hostname: discovery-service
-  client.serviceUrl.defaultZone: http://discovery-service:9090/eureka/
-fda:
-  ready.path: /ready
\ No newline at end of file

dbrepo-discovery-service/rest-service/src/main/resources/application-local.yml

@@ -20,6 +20,10 @@ spring:
           time_zone: UTC
   application:
     name: discovery-service
+  rabbitmq:
+    host: localhost
+    username: fda
+    password: fda
   cloud:
     loadbalancer.ribbon.enabled: false
     gateway:
@@ -47,3 +51,4 @@ eureka:
     secure-port: 9090
 fda:
   ready.path: ./ready
+  gateway.endpoint: http://localhost:9095
\ No newline at end of file

dbrepo-discovery-service/rest-service/src/main/resources/application.yml

@@ -18,6 +18,10 @@ spring:
           time_zone: UTC
   application:
     name: discovery-service
+  rabbitmq:
+    host: broker-service
+    username: "${BROKER_USERNAME}"
+    password: "${BROKER_PASSWORD}"
   cloud:
     loadbalancer.ribbon.enabled: false
 management.endpoints.web.exposure.include: health,info,prometheus
@@ -41,3 +45,4 @@ eureka:
     secure-port: 9090
 fda:
   ready.path: /ready
+  gateway.endpoint: "${GATEWAY_ENDPOINT}"
\ No newline at end of file

dbrepo-discovery-service/rest-service/src/test/java/at/tuwien/BaseUnitTest.java

+package at.tuwien;
+
+import at.tuwien.test.BaseTest;
+import org.springframework.test.context.TestPropertySource;
+
+@TestPropertySource(locations = "classpath:application.properties")
+public abstract class BaseUnitTest extends BaseTest {
+
+}
\ No newline at end of file

dbrepo-discovery-service/rest-service/src/test/java/at/tuwien/MockServiceIntegrationTest.java

+package at.tuwien;
+
+import at.tuwien.config.H2Utils;
+import at.tuwien.service.MockService;
+import lombok.extern.log4j.Log4j2;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+@Log4j2
+@SpringBootTest
+public class MockServiceIntegrationTest extends BaseUnitTest {
+
+    @Autowired
+    private H2Utils h2Utils;
+
+    @Autowired
+    private MockService mockService;
+
+    @BeforeEach
+    public void beforeEach() {
+        h2Utils.runScript("schema.sql");
+    }
+
+    @Test
+    public void mock_succeeds() {
+
+        /* test */
+        final Boolean response = mockService.mock();
+        assertTrue(response);
+    }
+
+}

dbrepo-discovery-service/rest-service/src/test/resources/schema.sql

+CREATE SCHEMA IF NOT EXISTS `fda`;
+SET SCHEMA `fda`;
+DROP TABLE IF EXISTS fda.mdb_concepts;
+CREATE TABLE IF NOT EXISTS fda.mdb_concepts
+(
+    uri        VARCHAR(500) not null,
+    name       VARCHAR(255),
+    created    timestamp    NOT NULL DEFAULT NOW(),
+    created_by bigint,
+    PRIMARY KEY (uri)
+);
+DROP TABLE IF EXISTS fda.mdb_units;
+CREATE TABLE IF NOT EXISTS fda.mdb_units
+(
+    uri        VARCHAR(500) not null,
+    name       VARCHAR(255),
+    created    timestamp    NOT NULL DEFAULT NOW(),
+    created_by bigint,
+    PRIMARY KEY (uri)
+);
+-- Modified for H2
+-- Assume id=1 is invalid
+-- Assume id=2 is still valid token
+-- CREATE VIEW IF NOT EXISTS fda.mdb_invalid_tokens AS
+-- (SELECT `id`, `token_hash`, `creator`, `created`, `expires`, `last_used` FROM fda.`mdb_tokens` WHERE `id` = 1);
\ No newline at end of file

dbrepo-metadata-service/pom.xml

@@ -196,9 +196,10 @@
                         <exclude>at/tuwien/utils/**/*</exclude>
                         <exclude>at/tuwien/seeder/**/*</exclude>
                         <exclude>at/tuwien/mapper/**/*</exclude>
+                        <exclude>at/tuwien/handlers/**/*</exclude>
                         <exclude>at/tuwien/exception/**/*</exclude>
                         <exclude>at/tuwien/config/**/*</exclude>
-                        <exclude>**/DbrepoContainerManagingApplication.class</exclude>
+                        <exclude>**/DbrepoMetadataServiceApplication.class</exclude>
                     </excludes>
                 </configuration>
                 <executions>

dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/MetadataEndpoint.java

@@ -47,7 +47,7 @@ public class MetadataEndpoint {
                     description = "List containers",
                     content = {@Content(mediaType = "text/xml")}),
     })
-    public ResponseEntity<?> identify() {
+    public ResponseEntity<String> identify() {
         log.debug("endpoint identify repository");
         return identifyAlt();
     }
@@ -60,7 +60,7 @@ public class MetadataEndpoint {
                     description = "List containers",
                     content = {@Content(mediaType = "text/xml")}),
     })
-    public ResponseEntity<?> identifyAlt() {
+    public ResponseEntity<String> identifyAlt() {
         log.debug("endpoint identify repository, verb=Identify");
         final String xml = metadataService.identify();
         log.trace("identify repository resulted in xml {}", xml);
@@ -70,7 +70,7 @@ public class MetadataEndpoint {
     @GetMapping(params = "verb=ListIdentifiers", produces = "text/xml;charset=UTF-8")
     @Timed(value = "identifiers.list", description = "Time needed to list the identifiers")
     @Operation(summary = "List the identifiers")
-    public ResponseEntity<?> listIdentifiers(OaiListIdentifiersParameters parameters) {
+    public ResponseEntity<String> listIdentifiers(OaiListIdentifiersParameters parameters) {
         log.debug("endpoint list identifiers, verb=ListIdentifiers, parameters={}", parameters);
         final String xml = metadataService.listIdentifiers(parameters);
         log.trace("list identifiers resulted in xml {}", xml);
@@ -80,9 +80,9 @@ public class MetadataEndpoint {
     @GetMapping(params = "verb=GetRecord", produces = "text/xml;charset=UTF-8")
     @Timed(value = "record.find", description = "Time needed to find a record")
     @Operation(summary = "Get the record")
-    public ResponseEntity<?> getRecord(OaiRecordParameters parameters) {
+    public ResponseEntity<String> getRecord(OaiRecordParameters parameters) {
         log.debug("endpoint get record, verb=GetRecord, parameters={}", parameters);
-        if (!parameters.getMetadataPrefix().equals("oai_dc")) {
+        if (parameters.getMetadataPrefix() != null && !parameters.getMetadataPrefix().equals("oai_dc")) {
             log.trace("metadataPrefix matches oai_dc, failed to serve this format");
             return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                     .body(metadataService.error(OaiErrorType.CANNOT_DISSEMINATE_FORMAT));
@@ -105,7 +105,7 @@ public class MetadataEndpoint {
     @GetMapping(params = "verb=ListMetadataFormats", produces = "text/xml;charset=UTF-8")
     @Timed(value = "formats.list", description = "Time needed to list the metadata formats")
     @Operation(summary = "List the metadata formats")
-    public ResponseEntity<?> listMetadataFormats() {
+    public ResponseEntity<String> listMetadataFormats() {
         log.debug("endpoint list metadata formats, verb=ListMetadataFormats");
         final String xml = metadataService.listMetadataFormats();
         log.trace("list metadata formats resulted in xml {}", xml);

dbrepo-metadata-service/rest-service/src/main/resources/templates/record.xml

@@ -10,7 +10,7 @@
                 <dc:title>[[${title}]]</dc:title>
                 <dc:publisher>[[${publisher}]]</dc:publisher>
                 <dc:description>[[${description}]]</dc:description>
-                <dc:creator th:each="creator: ${identifier.getCreators()}">[(${creator.getLastname()})], [(${creator.getFirstname()})]</dc:creator>
+                <dc:creator th:each="creator: ${creators}">[(${creator.getLastname()})], [(${creator.getFirstname()})]</dc:creator>
             </oai_dc:dc>
         </metadata>
     </record>

dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/endpoints/MetadataEndpointUnitTest.java

+package at.tuwien.endpoints;
+
+import at.tuwien.BaseUnitTest;
+import at.tuwien.OaiListIdentifiersParameters;
+import at.tuwien.OaiRecordParameters;
+import at.tuwien.config.H2Utils;
+import at.tuwien.entities.identifier.Identifier;
+import at.tuwien.exception.IdentifierNotFoundException;
+import at.tuwien.repository.jpa.*;
+import at.tuwien.service.IdentifierService;
+import lombok.extern.log4j.Log4j2;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.when;
+
+@Log4j2
+@SpringBootTest
+@ExtendWith(SpringExtension.class)
+public class MetadataEndpointUnitTest extends BaseUnitTest {
+
+    @MockBean
+    private IdentifierRepository identifierRepository;
+
+    @Autowired
+    private MetadataEndpoint metadataEndpoint;
+
+    @Autowired
+    private H2Utils h2Utils;
+
+    @BeforeEach
+    public void beforeEach() {
+        /* schema */
+        h2Utils.runScript("schema.sql");
+    }
+
+    @Test
+    public void identify_succeeds() {
+
+        /* test */
+        final ResponseEntity<String> response = metadataEndpoint.identify();
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        final String body = response.getBody();
+        assertNotNull(body);
+    }
+
+    @Test
+    public void identifyAlt_succeeds() {
+
+        /* test */
+        final ResponseEntity<String> response = metadataEndpoint.identifyAlt();
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        final String body = response.getBody();
+        assertNotNull(body);
+    }
+
+    @Test
+    public void listIdentifiers_succeeds() {
+        final OaiListIdentifiersParameters parameters = new OaiListIdentifiersParameters();
+
+        /* mock */
+        when(identifierRepository.findAll())
+                .thenReturn(List.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<String> response = metadataEndpoint.listIdentifiers(parameters);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        final String body = response.getBody();
+        assertNotNull(body);
+    }
+
+    @Test
+    public void getRecord_formatMissing_fails() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<?> response = metadataEndpoint.getRecord(parameters);
+        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    }
+
+    @Test
+    public void getRecord_unsupportedFormat_fails() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setMetadataPrefix("oai_marc");
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<?> response = metadataEndpoint.getRecord(parameters);
+        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    }
+
+    @Test
+    public void getRecord_noIdentifier_fails() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setMetadataPrefix("oai_dc");
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<?> response = metadataEndpoint.getRecord(parameters);
+        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    }
+
+    @Test
+    public void getRecord_succeeds() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setMetadataPrefix("oai_dc");
+        parameters.setIdentifier(Long.toString(1L));
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<String> response = metadataEndpoint.getRecord(parameters);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        final String body = response.getBody();
+        assertNotNull(body);
+    }
+
+    @Test
+    public void getRecord_notFound_fails() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setMetadataPrefix("oai_dc");
+        parameters.setIdentifier(Long.toString(9999L));
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<?> response = metadataEndpoint.getRecord(parameters);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+    }
+
+    @Test
+    public void listMetadataFormats_succeeds() {
+
+        /* mock */
+        when(identifierRepository.findById(IDENTIFIER_1_ID))
+                .thenReturn(Optional.of(IDENTIFIER_1));
+
+        /* test */
+        final ResponseEntity<String> response = metadataEndpoint.listMetadataFormats();
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        final String body = response.getBody();
+        assertNotNull(body);
+    }
+
+}

dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/IdentifierServiceIntegrationTest.java

+package at.tuwien.service;
+
+import at.tuwien.BaseUnitTest;
+import at.tuwien.config.H2Utils;
+import at.tuwien.entities.identifier.Identifier;
+import at.tuwien.exception.IdentifierNotFoundException;
+import at.tuwien.repository.jpa.*;
+import lombok.extern.log4j.Log4j2;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@Log4j2
+@SpringBootTest
+@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
+@ExtendWith(SpringExtension.class)
+public class IdentifierServiceIntegrationTest extends BaseUnitTest {
+
+    @Autowired
+    private ImageRepository imageRepository;
+
+    @Autowired
+    private ContainerRepository containerRepository;
+
+    @Autowired
+    private DatabaseRepository databaseRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private RealmRepository realmRepository;
+
+    @Autowired
+    private IdentifierRepository identifierRepository;
+
+    @Autowired
+    private IdentifierService identifierService;
+
+    @Autowired
+    private H2Utils h2Utils;
+
+    @BeforeEach
+    public void beforeEach() {
+        /* schema */
+        h2Utils.runScript("schema.sql");
+        /* metadata database */
+        imageRepository.save(IMAGE_1_SIMPLE);
+        realmRepository.save(REALM_DBREPO);
+        userRepository.save(USER_1_SIMPLE);
+        containerRepository.save(CONTAINER_1_SIMPLE);
+        databaseRepository.save(DATABASE_1_SIMPLE);
+        identifierRepository.save(IDENTIFIER_1_SIMPLE);
+    }
+
+    @Test
+    public void findAll_succeeds() {
+
+        /* test */
+        final List<Identifier> response = identifierService.findAll();
+        assertEquals(1, response.size());
+    }
+
+    @Test
+    public void find_succeeds() throws IdentifierNotFoundException {
+
+        /* test */
+        final Identifier response = identifierService.find(IDENTIFIER_1_ID);
+        assertEquals(IDENTIFIER_1_ID, response.getId());
+        assertEquals(IDENTIFIER_1_TITLE, response.getTitle());
+    }
+
+    @Test
+    public void find_fails() {
+
+        /* test */
+        assertThrows(IdentifierNotFoundException.class, () -> {
+            identifierService.find(IDENTIFIER_2_ID);
+        });
+    }
+
+}

dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/MetadataServiceIntegrationTest.java

+package at.tuwien.service;
+
+import at.tuwien.BaseUnitTest;
+import at.tuwien.OaiErrorType;
+import at.tuwien.OaiListIdentifiersParameters;
+import at.tuwien.OaiRecordParameters;
+import at.tuwien.config.H2Utils;
+import at.tuwien.exception.IdentifierNotFoundException;
+import at.tuwien.repository.jpa.*;
+import lombok.extern.log4j.Log4j2;
+import org.apache.commons.io.FileUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@Log4j2
+@SpringBootTest
+@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
+@ExtendWith(SpringExtension.class)
+public class MetadataServiceIntegrationTest extends BaseUnitTest {
+
+    @Autowired
+    private ImageRepository imageRepository;
+
+    @Autowired
+    private ContainerRepository containerRepository;
+
+    @Autowired
+    private DatabaseRepository databaseRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private RealmRepository realmRepository;
+
+    @Autowired
+    private IdentifierRepository identifierRepository;
+
+    @Autowired
+    private MetadataService metadataService;
+
+    @Autowired
+    private H2Utils h2Utils;
+
+    @BeforeEach
+    public void beforeEach() {
+        /* schema */
+        h2Utils.runScript("schema.sql");
+        /* metadata database */
+        imageRepository.save(IMAGE_1_SIMPLE);
+        realmRepository.save(REALM_DBREPO);
+        userRepository.save(USER_1_SIMPLE);
+        containerRepository.save(CONTAINER_1_SIMPLE);
+        databaseRepository.save(DATABASE_1_SIMPLE);
+        identifierRepository.save(IDENTIFIER_1_SIMPLE);
+    }
+
+    @Test
+    public void identify_succeeds() {
+
+        /* test */
+        final String response = metadataService.identify();
+        assertTrue(response.contains("repositoryName"));
+        assertTrue(response.contains("baseURL"));
+        assertTrue(response.contains("adminEmail"));
+        assertTrue(response.contains("earliestDatestamp"));
+        assertTrue(response.contains("deletedRecord"));
+        assertTrue(response.contains("granularity"));
+    }
+
+    @Test
+    public void listIdentifiers_succeeds() {
+        final OaiListIdentifiersParameters parameters = new OaiListIdentifiersParameters();
+
+        /* test */
+        final String response = metadataService.listIdentifiers(parameters);
+        assertTrue(response.contains("identifier"));
+        assertTrue(response.contains("datestamp"));
+    }
+
+    @Test
+    public void listMetadataFormats_succeeds() {
+
+        /* test */
+        final String response = metadataService.listMetadataFormats();
+        assertTrue(response.contains("metadataPrefix"));
+        assertTrue(response.contains("schema"));
+        assertTrue(response.contains("metadataNamespace"));
+    }
+
+    @Test
+    public void error_succeeds() {
+
+        /* test */
+        final String response = metadataService.error(OaiErrorType.CANNOT_DISSEMINATE_FORMAT);
+        assertTrue(response.contains("error"));
+    }
+
+    @Test
+    public void getRecord_succeeds() throws IdentifierNotFoundException {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setIdentifier(Long.toString(1L));
+
+        /* test */
+        final String response = metadataService.getRecord(parameters);
+        assertTrue(response.contains("identifier"));
+        assertTrue(response.contains("datestamp"));
+        assertTrue(response.contains("title"));
+        assertTrue(response.contains("description"));
+        assertTrue(response.contains("publisher"));
+    }
+
+    @Test
+    public void getRecord_fails() {
+        final OaiRecordParameters parameters = new OaiRecordParameters();
+        parameters.setIdentifier(Long.toString(9999L));
+
+        /* test */
+        assertThrows(IdentifierNotFoundException.class, () -> {
+            metadataService.getRecord(parameters);
+        });
+    }
+
+}

dbrepo-metadata-service/rest-service/src/test/resources/schema.sql

+CREATE SCHEMA IF NOT EXISTS `fda`;
+SET SCHEMA `fda`;
+DROP TABLE IF EXISTS fda.mdb_concepts;
+CREATE TABLE IF NOT EXISTS fda.mdb_concepts
+(
+    uri        VARCHAR(500) not null,
+    name       VARCHAR(255),
+    created    timestamp    NOT NULL DEFAULT NOW(),
+    created_by bigint,
+    PRIMARY KEY (uri)
+);
+DROP TABLE IF EXISTS fda.mdb_units;
+CREATE TABLE IF NOT EXISTS fda.mdb_units
+(
+    uri        VARCHAR(500) not null,
+    name       VARCHAR(255),
+    created    timestamp    NOT NULL DEFAULT NOW(),
+    created_by bigint,
+    PRIMARY KEY (uri)
+);
+-- Modified for H2
+-- Assume id=1 is invalid
+-- Assume id=2 is still valid token
+-- CREATE VIEW IF NOT EXISTS fda.mdb_invalid_tokens AS
+-- (SELECT `id`, `token_hash`, `creator`, `created`, `expires`, `last_used` FROM fda.`mdb_tokens` WHERE `id` = 1);
\ No newline at end of file

dbrepo-metadata-service/services/src/main/java/at/tuwien/repository/jpa/ContainerRepository.java

+package at.tuwien.repository.jpa;
+
+import at.tuwien.entities.container.Container;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ContainerRepository extends JpaRepository<Container, Long> {
+}

dbrepo-metadata-service/services/src/main/java/at/tuwien/repository/jpa/DatabaseRepository.java

+package at.tuwien.repository.jpa;
+
+import at.tuwien.entities.database.Database;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface DatabaseRepository extends JpaRepository<Database, Long> {
+}

dbrepo-metadata-service/services/src/main/java/at/tuwien/repository/jpa/ImageRepository.java

+package at.tuwien.repository.jpa;
+
+import at.tuwien.entities.container.image.ContainerImage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ImageRepository extends JpaRepository<ContainerImage, Long> {
+}

dbrepo-metadata-service/services/src/main/java/at/tuwien/repository/jpa/RealmRepository.java

+package at.tuwien.repository.jpa;
+
+import at.tuwien.entities.user.Realm;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.UUID;
+
+@Repository
+public interface RealmRepository extends JpaRepository<Realm, UUID> {
+}