diff --git a/dbrepo-metadata-db/test/src/main/java/at/tuwien/config/MariaDbConfig.java b/dbrepo-metadata-db/test/src/main/java/at/tuwien/config/MariaDbConfig.java
index 8d00a9e77e0cb7674bdfd13d5d348244a08e0f92..bbab1efee9357de6eb3ebe77778384ef88454dc6 100644
--- a/dbrepo-metadata-db/test/src/main/java/at/tuwien/config/MariaDbConfig.java
+++ b/dbrepo-metadata-db/test/src/main/java/at/tuwien/config/MariaDbConfig.java
@@ -1,8 +1,12 @@
package at.tuwien.config;
+import at.tuwien.entities.container.Container;
+import at.tuwien.entities.database.Database;
import at.tuwien.querystore.Query;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import java.sql.*;
import java.util.HashMap;
@@ -14,54 +18,92 @@ import java.util.Map;
@Configuration
public class MariaDbConfig {
- public static void insertQueryStore(String hostname, String database, Query query, String username) throws SQLException {
- final String jdbc = "jdbc:mariadb://" + hostname + "/" + database;
+ public static void createInitDatabase(Container container, Database database) throws SQLException {
+ final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
log.trace("connect to database {}", jdbc);
- final Connection connection = DriverManager.getConnection(jdbc, "root", "mariadb");
- final PreparedStatement prepareStatement = connection.prepareStatement("INSERT INTO qs_queries (created_by, query, query_normalized, is_persisted, query_hash, result_hash, result_number, created, executed) VALUES (?,?,?,?,?,?,?,?,?)");
- prepareStatement.setString(1, username);
- prepareStatement.setString(2, query.getQuery());
- prepareStatement.setString(3, query.getQuery());
- prepareStatement.setBoolean(4, query.getIsPersisted());
- prepareStatement.setString(5, query.getQueryHash());
- prepareStatement.setString(6, query.getResultHash());
- prepareStatement.setLong(7, query.getResultNumber());
- prepareStatement.setTimestamp(8, Timestamp.from(query.getCreated()));
- prepareStatement.setTimestamp(9, Timestamp.from(query.getExecuted()));
- log.trace("prepared statement: {}", prepareStatement);
- prepareStatement.executeUpdate();
- connection.close();
+ try (Connection connection = DriverManager.getConnection(jdbc, container.getPrivilegedUsername(), container.getPrivilegedPassword())) {
+ ResourceDatabasePopulator populator = new ResourceDatabasePopulator(new ClassPathResource("init/" + database.getInternalName() + ".sql"), new ClassPathResource("init/querystore.sql"));
+ populator.setSeparator(";\n");
+ populator.populate(connection);
+ }
}
- public static List<Map<String, Object>> listQueryStore(String hostname, String database) throws SQLException {
- final String jdbc = "jdbc:mariadb://" + hostname + "/" + database;
+ public static void dropAllDatabases(Container container) {
+ final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
log.trace("connect to database {}", jdbc);
- final Connection connection = DriverManager.getConnection(jdbc, "root", "mariadb");
- final Statement statement = connection.createStatement();
- final ResultSet result = statement.executeQuery("SELECT created_by, query, query_normalized, is_persisted, query_hash, result_hash, result_number, created, executed FROM qs_queries");
- final List<Map<String, Object>> rows = new LinkedList<>();
- while (result.next()) {
- rows.add(new HashMap<>() {{
- put("created_by", result.getString(1));
- put("query", result.getString(2));
- put("query_normalized", result.getString(3));
- put("is_persisted", result.getBoolean(4));
- put("query_hash", result.getString(5));
- put("result_hash", result.getString(6));
- put("result_number", result.getLong(7));
- put("created", result.getTimestamp(8));
- put("executed", result.getTimestamp(9));
- }});
+ try (Connection connection = DriverManager.getConnection(jdbc, container.getPrivilegedUsername(), container.getPrivilegedPassword())) {
+ final String sql = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME NOT IN ('information_schema', 'mysql', 'performance_schema');";
+ log.trace("prepare statement '{}'", sql);
+ final PreparedStatement statement = connection.prepareStatement(sql);
+ final ResultSet resultSet = statement.executeQuery();
+ final List<String> databases = new LinkedList<>();
+ while (resultSet.next()) {
+ databases.add(resultSet.getString(1));
+ }
+ resultSet.close();
+ statement.close();
+ for (String database : databases) {
+ final String drop = "DROP DATABASE IF EXISTS `" + database + "`;";
+ final PreparedStatement dropStatement = connection.prepareStatement(drop);
+ dropStatement.executeUpdate();
+ dropStatement.close();
+ }
+ } catch (SQLException e) {
+ log.error("could not drop all databases", e);
+ }
+ }
+
+ public static void insertQueryStore(Database database, Query query, String username) throws SQLException {
+ final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
+ log.trace("connect to database {}", jdbc);
+ try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getPrivilegedUsername(), database.getContainer().getPrivilegedPassword())) {
+ final PreparedStatement prepareStatement = connection.prepareStatement(
+ "INSERT INTO qs_queries (created_by, query, query_normalized, is_persisted, query_hash, result_hash, result_number, created, executed) VALUES (?,?,?,?,?,?,?,?,?)");
+ prepareStatement.setString(1, username);
+ prepareStatement.setString(2, query.getQuery());
+ prepareStatement.setString(3, query.getQuery());
+ prepareStatement.setBoolean(4, query.getIsPersisted());
+ prepareStatement.setString(5, query.getQueryHash());
+ prepareStatement.setString(6, query.getResultHash());
+ prepareStatement.setLong(7, query.getResultNumber());
+ prepareStatement.setTimestamp(8, Timestamp.from(query.getCreated()));
+ prepareStatement.setTimestamp(9, Timestamp.from(query.getExecuted()));
+ log.trace("prepared statement: {}", prepareStatement);
+ prepareStatement.executeUpdate();
+ }
+ }
+
+ public static List<Map<String, Object>> listQueryStore(Database database) throws SQLException {
+ final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
+ log.trace("connect to database {}", jdbc);
+ try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getPrivilegedUsername(), database.getContainer().getPrivilegedPassword())) {
+ final Statement statement = connection.createStatement();
+ final ResultSet result = statement.executeQuery(
+ "SELECT created_by, query, query_normalized, is_persisted, query_hash, result_hash, result_number, created, executed FROM qs_queries");
+ final List<Map<String, Object>> rows = new LinkedList<>();
+ while (result.next()) {
+ rows.add(new HashMap<>() {{
+ put("created_by", result.getString(1));
+ put("query", result.getString(2));
+ put("query_normalized", result.getString(3));
+ put("is_persisted", result.getBoolean(4));
+ put("query_hash", result.getString(5));
+ put("result_hash", result.getString(6));
+ put("result_number", result.getLong(7));
+ put("created", result.getTimestamp(8));
+ put("executed", result.getTimestamp(9));
+ }});
+ }
+ return rows;
}
- return rows;
}
- public static List<Map<String, String>> selectQuery(String hostname, String database, String query, String... columns)
+ public static List<Map<String, String>> selectQuery(Database database, String query, String... columns)
throws SQLException {
- final String jdbc = "jdbc:mariadb://" + hostname + "/" + database;
+ final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
log.trace("connect to database {}", jdbc);
final List<Map<String, String>> rows = new LinkedList<>();
- try (Connection connection = DriverManager.getConnection(jdbc, "root", "mariadb")) {
+ try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getPrivilegedUsername(), database.getContainer().getPrivilegedPassword())) {
final Statement statement = connection.createStatement();
final ResultSet result = statement.executeQuery(query);
while (result.next()) {
@@ -75,11 +117,11 @@ public class MariaDbConfig {
return rows;
}
- public static void execute(String hostname, String database, String query)
+ public static void execute(Database database, String query)
throws SQLException {
- final String jdbc = "jdbc:mariadb://" + hostname + "/" + database;
+ final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
log.trace("connect to database {}", jdbc);
- try (Connection connection = DriverManager.getConnection(jdbc, "root", "mariadb")) {
+ try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getPrivilegedUsername(), database.getContainer().getPrivilegedPassword())) {
final Statement statement = connection.createStatement();
statement.executeUpdate(query);
}
diff --git a/dbrepo-query-service/pom.xml b/dbrepo-query-service/pom.xml
index 73c0a87169dcd8cc59ba1631076bba6df45f5766..ea6976eb0c077c579debcd148af79d88bc592484 100644
--- a/dbrepo-query-service/pom.xml
+++ b/dbrepo-query-service/pom.xml
@@ -43,7 +43,6 @@
<java.version>17</java.version>
<spring-cloud.version>4.0.2</spring-cloud.version>
<mapstruct.version>1.5.5.Final</mapstruct.version>
- <docker.version>3.3.0</docker.version>
<jacoco.version>0.8.10</jacoco.version>
<jwt.version>4.3.0</jwt.version>
<opencsv.version>5.7.1</opencsv.version>
@@ -51,6 +50,9 @@
<c3p0.version>0.9.5.5</c3p0.version>
<c3p0-hibernate.version>6.2.2.Final</c3p0-hibernate.version>
<springdoc-openapi.version>2.1.0</springdoc-openapi.version>
+ <hsqldb.version>2.7.2</hsqldb.version>
+ <testcontainers.version>1.18.3</testcontainers.version>
+ <opensearch-testcontainer.version>2.0.0</opensearch-testcontainer.version>
<opensearch-client.version>1.1.0</opensearch-client.version>
</properties>
@@ -149,24 +151,6 @@
<artifactId>springdoc-openapi-starter-webmvc-api</artifactId>
<version>${springdoc-openapi.version}</version>
</dependency>
- <!-- Docker -->
- <dependency>
- <groupId>com.github.docker-java</groupId>
- <artifactId>docker-java</artifactId>
- <version>${docker.version}</version>
- <exclusions>
- <exclusion>
- <groupId>javax.ws.rs</groupId>
- <artifactId>jsr311-api</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>com.github.docker-java</groupId>
- <artifactId>docker-java-transport-httpclient5</artifactId>
- <version>${docker.version}</version>
- </dependency>
- <!-- IDE -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
@@ -209,8 +193,33 @@
</exclusions>
</dependency>
<dependency>
- <groupId>com.h2database</groupId>
- <artifactId>h2</artifactId>
+ <groupId>org.hsqldb</groupId>
+ <artifactId>hsqldb</artifactId>
+ <version>${hsqldb.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <version>${testcontainers.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>mariadb</artifactId>
+ <version>${testcontainers.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>rabbitmq</artifactId>
+ <version>${testcontainers.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opensearch</groupId>
+ <artifactId>opensearch-testcontainers</artifactId>
+ <version>${opensearch-testcontainer.version}</version>
<scope>test</scope>
</dependency>
<dependency>
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ExportEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ExportEndpoint.java
index d052feb732d18187f264ce2b44f973e0cc879f8c..60b0aea9fa02676122d337365b85068bcdca120e 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ExportEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ExportEndpoint.java
@@ -4,10 +4,12 @@ import at.tuwien.ExportResource;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
-import at.tuwien.service.*;
+import at.tuwien.service.DatabaseService;
+import at.tuwien.service.QueryService;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.InputStreamResource;
@@ -16,14 +18,13 @@ import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
import java.time.Instant;
@Log4j2
@CrossOrigin(origins = "*")
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/table/{tableId}/export")
+@RequestMapping("/api/database/{id}/table/{tableId}/export")
public class ExportEndpoint {
private final QueryService queryService;
@@ -39,17 +40,15 @@ public class ExportEndpoint {
@Transactional(readOnly = true)
@Timed(value = "table.export", description = "Time needed to export table data")
@Operation(summary = "Export table", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<InputStreamResource> export(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<InputStreamResource> export(@NotNull @PathVariable("id") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@RequestParam(required = false) Instant timestamp,
Principal principal)
throws TableNotFoundException, DatabaseConnectionException, TableMalformedException,
DatabaseNotFoundException, ImageNotSupportedException, PaginationException, ContainerNotFoundException,
FileStorageException, QueryMalformedException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint export table, id={}, databaseId={}, tableId={}, timestamp={}, principal={}", containerId, databaseId,
- tableId, timestamp, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ log.debug("endpoint export table, id={}, tableId={}, timestamp={}, principal={}", databaseId, tableId, timestamp, principal);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic()) {
if (principal == null) {
log.error("Failed to export private table: principal is null");
@@ -61,7 +60,7 @@ public class ExportEndpoint {
}
}
final HttpHeaders headers = new HttpHeaders();
- final ExportResource resource = queryService.tableFindAll(containerId, databaseId, tableId, timestamp, principal);
+ final ExportResource resource = queryService.tableFindAll(databaseId, tableId, timestamp, principal);
headers.add("Content-Disposition", "attachment; filename=\"" + resource.getFilename() + "\"");
log.trace("export table resulted in resource {}", resource);
return ResponseEntity.ok()
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/QueryEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/QueryEndpoint.java
index 6224be726b5b0b8a9cfd110857652d4780d32a12..a72681599bfbc7a974071582084e91e2549f0f6d 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/QueryEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/QueryEndpoint.java
@@ -2,16 +2,22 @@ package at.tuwien.endpoint;
import at.tuwien.ExportResource;
import at.tuwien.SortType;
-import at.tuwien.api.database.query.*;
+import at.tuwien.api.database.query.ExecuteStatementDto;
+import at.tuwien.api.database.query.QueryResultDto;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.user.User;
-import at.tuwien.querystore.Query;
import at.tuwien.exception.*;
-import at.tuwien.service.*;
+import at.tuwien.querystore.Query;
+import at.tuwien.service.AccessService;
+import at.tuwien.service.DatabaseService;
+import at.tuwien.service.QueryService;
+import at.tuwien.service.StoreService;
import at.tuwien.validation.EndpointValidator;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
@@ -21,14 +27,12 @@ import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
@Log4j2
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/query")
+@RequestMapping("/api/database/{databaseId}/query")
public class QueryEndpoint {
private final QueryService queryService;
@@ -52,8 +56,7 @@ public class QueryEndpoint {
@Timed(value = "query.execute", description = "Time needed to execute a query")
@PreAuthorize("hasAuthority('execute-query')")
@Operation(summary = "Execute query", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<QueryResultDto> execute(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryResultDto> execute(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @Valid @RequestBody ExecuteStatementDto data,
@RequestParam(value = "page", required = false) Long page,
@RequestParam(value = "size", required = false) Long size,
@@ -63,8 +66,8 @@ public class QueryEndpoint {
throws DatabaseNotFoundException, ImageNotSupportedException, QueryStoreException, QueryMalformedException,
ContainerNotFoundException, ColumnParseException, UserNotFoundException, TableMalformedException,
DatabaseConnectionException, SortException, PaginationException, NotAllowedException {
- log.debug("endpoint execute query, containerId={}, databaseId={}, data={}, page={}, size={}, principal={}, sortDirection={}, sortColumn={}",
- containerId, databaseId, data, page, size, principal, sortDirection, sortColumn);
+ log.debug("endpoint execute query, databaseId={}, data={}, page={}, size={}, principal={}, sortDirection={}, sortColumn={}",
+ databaseId, data, page, size, principal, sortDirection, sortColumn);
/* check */
if (data.getStatement() == null || data.getStatement().isBlank()) {
log.error("Failed to execute empty query");
@@ -75,7 +78,7 @@ public class QueryEndpoint {
/* has access */
accessService.find(databaseId, principal.getName());
/* execute */
- final QueryResultDto result = queryService.execute(containerId, databaseId, data, principal, page, size,
+ final QueryResultDto result = queryService.execute(databaseId, data, principal, page, size,
sortDirection, sortColumn);
log.trace("execute query resulted in result {}", result);
return ResponseEntity.status(HttpStatus.ACCEPTED)
@@ -86,8 +89,7 @@ public class QueryEndpoint {
@Transactional(readOnly = true)
@Timed(value = "query.reexecute", description = "Time needed to re-execute a query")
@Operation(summary = "Re-execute some query", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<QueryResultDto> reExecute(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryResultDto> reExecute(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("queryId") Long queryId,
Principal principal,
@RequestParam(value = "page", required = false) Long page,
@@ -97,10 +99,10 @@ public class QueryEndpoint {
throws QueryStoreException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException,
QueryMalformedException, TableMalformedException, ColumnParseException,
DatabaseConnectionException, SortException, PaginationException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint re-execute query, containerId={}, databaseId={}, queryId={}, principal={}, page={}, size={}, sortDirection={}, sortColumn={}",
- containerId, databaseId, queryId, principal, page, size, sortDirection, sortColumn);
+ log.debug("endpoint re-execute query, databaseId={}, queryId={}, principal={}, page={}, size={}, sortDirection={}, sortColumn={}",
+ databaseId, queryId, principal, page, size, sortDirection, sortColumn);
endpointValidator.validateDataParams(page, size, sortDirection, sortColumn);
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic()) {
if (principal == null) {
log.error("Failed to re-execute private query: principal is null");
@@ -112,8 +114,8 @@ public class QueryEndpoint {
}
}
/* execute */
- final Query query = storeService.findOne(containerId, databaseId, queryId, principal);
- final QueryResultDto result = queryService.reExecute(containerId, databaseId, query, page, size,
+ final Query query = storeService.findOne(databaseId, queryId, principal);
+ final QueryResultDto result = queryService.reExecute(databaseId, query, page, size,
sortDirection, sortColumn, principal);
result.setId(queryId);
log.trace("re-execute query resulted in result {}", result);
@@ -125,16 +127,15 @@ public class QueryEndpoint {
@Transactional(readOnly = true)
@Timed(value = "query.reexecute.count", description = "Time needed to re-execute a query")
@Operation(summary = "Re-execute some query", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Long> reExecuteCount(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Long> reExecuteCount(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("queryId") Long queryId,
Principal principal)
throws QueryStoreException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException,
QueryMalformedException, TableMalformedException, ColumnParseException, NotAllowedException,
DatabaseConnectionException, UserNotFoundException {
- log.debug("endpoint re-execute query count, containerId={}, databaseId={}, queryId={}, principal={}",
- containerId, databaseId, queryId, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ log.debug("endpoint re-execute query count, databaseId={}, queryId={}, principal={}",
+ databaseId, queryId, principal);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic()) {
if (principal == null) {
log.error("Failed to re-execute private query: principal is null");
@@ -146,8 +147,8 @@ public class QueryEndpoint {
}
}
/* execute */
- final Query query = storeService.findOne(containerId, databaseId, queryId, principal);
- final Long result = queryService.reExecuteCount(containerId, databaseId, query, principal);
+ final Query query = storeService.findOne(databaseId, queryId, principal);
+ final Long result = queryService.reExecuteCount(databaseId, query, principal);
log.trace("re-execute query count resulted in result {}", result);
return ResponseEntity.status(HttpStatus.ACCEPTED)
.body(result);
@@ -157,17 +158,16 @@ public class QueryEndpoint {
@Transactional(readOnly = true)
@Timed(value = "query.export", description = "Time needed to export query data")
@Operation(summary = "Exports some query", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<?> export(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<?> export(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("queryId") Long queryId,
@RequestHeader(HttpHeaders.ACCEPT) String accept,
Principal principal)
throws QueryStoreException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException,
ContainerNotFoundException, TableMalformedException, FileStorageException, QueryMalformedException,
DatabaseConnectionException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint export query, containerId={}, databaseId={}, queryId={}, accept={}, principal={}",
- containerId, databaseId, queryId, accept, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ log.debug("endpoint export query, databaseId={}, queryId={}, accept={}, principal={}",
+ databaseId, queryId, accept, principal);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic()) {
if (principal == null) {
log.error("Failed to export private query: principal is null");
@@ -178,9 +178,9 @@ public class QueryEndpoint {
throw new NotAllowedException("Failed to export private query: role missing");
}
}
- final Query query = storeService.findOne(containerId, databaseId, queryId, principal);
+ final Query query = storeService.findOne(databaseId, queryId, principal);
log.trace("query store returned query {}", query);
- final ExportResource resource = queryService.findOne(containerId, databaseId, queryId, principal);
+ final ExportResource resource = queryService.findOne(databaseId, queryId, principal);
if (accept == null || accept.equals("text/csv")) {
final HttpHeaders headers = new HttpHeaders();
headers.add("Content-Disposition", "attachment; filename=\"" + resource.getFilename() + "\"");
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/StoreEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/StoreEndpoint.java
index 9b043f3ea97bb51a9f17319450340ac2f26eaf45..a3f78915ea33b1206ef2c34204f80f1b37c1c1cf 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/StoreEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/StoreEndpoint.java
@@ -2,17 +2,19 @@ package at.tuwien.endpoint;
import at.tuwien.api.database.query.QueryBriefDto;
import at.tuwien.api.database.query.QueryDto;
-import at.tuwien.api.database.table.TableBriefDto;
import at.tuwien.api.error.ApiErrorDto;
import at.tuwien.entities.identifier.Identifier;
import at.tuwien.entities.identifier.IdentifierType;
import at.tuwien.entities.user.User;
+import at.tuwien.exception.*;
import at.tuwien.mapper.IdentifierMapper;
+import at.tuwien.mapper.QueryMapper;
import at.tuwien.mapper.UserMapper;
import at.tuwien.querystore.Query;
-import at.tuwien.exception.*;
-import at.tuwien.mapper.QueryMapper;
-import at.tuwien.service.*;
+import at.tuwien.service.AccessService;
+import at.tuwien.service.IdentifierService;
+import at.tuwien.service.StoreService;
+import at.tuwien.service.UserService;
import at.tuwien.validation.EndpointValidator;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
@@ -22,6 +24,7 @@ import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
@@ -30,7 +33,6 @@ import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
import java.util.List;
import java.util.Optional;
@@ -38,7 +40,7 @@ import java.util.stream.Collectors;
@Log4j2
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/query")
+@RequestMapping("/api/database/{databaseId}/query")
public class StoreEndpoint {
private final UserMapper userMapper;
@@ -105,16 +107,15 @@ public class StoreEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<List<QueryBriefDto>> findAll(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<List<QueryBriefDto>> findAll(@NotNull @PathVariable("databaseId") Long databaseId,
@RequestParam(value = "persisted", required = false) Boolean persisted,
Principal principal) throws QueryStoreException,
DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException,
DatabaseConnectionException, TableMalformedException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint list queries, containerId={}, databaseId={}, persisted={}, principal={}", containerId,
+ log.debug("endpoint list queries, databaseId={}, persisted={}, principal={}",
databaseId, persisted, principal);
- endpointValidator.validateOnlyAccessOrPublic(containerId, databaseId, principal);
- final List<Query> queries = storeService.findAll(containerId, databaseId, persisted, principal);
+ endpointValidator.validateOnlyAccessOrPublic(databaseId, principal);
+ final List<Query> queries = storeService.findAll(databaseId, persisted, principal);
final List<Identifier> identifiers = identifierService.findAll();
final List<User> users = userService.findAll();
final List<QueryBriefDto> dto = queries.stream()
@@ -171,19 +172,18 @@ public class StoreEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<QueryDto> find(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryDto> find(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable Long queryId,
Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException,
QueryStoreException, QueryNotFoundException, UserNotFoundException, NotAllowedException,
DatabaseConnectionException {
- log.debug("endpoint find query, containerId={}, databaseId={}, queryId={}, principal={}", containerId, databaseId,
+ log.debug("endpoint find query, databaseId={}, queryId={}, principal={}", databaseId,
queryId, principal);
/* check */
- endpointValidator.validateOnlyAccessOrPublic(containerId, databaseId, principal);
+ endpointValidator.validateOnlyAccessOrPublic(databaseId, principal);
/* find */
- final Query query = storeService.findOne(containerId, databaseId, queryId, principal);
+ final Query query = storeService.findOne(databaseId, queryId, principal);
final QueryDto dto = queryMapper.queryToQueryDto(query);
final User creator = userService.findByUsername(query.getCreatedBy());
dto.setCreator(userMapper.userToUserDto(creator));
@@ -234,18 +234,17 @@ public class StoreEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<QueryDto> persist(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryDto> persist(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("queryId") Long queryId,
@NotNull Principal principal)
throws QueryStoreException, DatabaseNotFoundException, ImageNotSupportedException,
DatabaseConnectionException, UserNotFoundException, QueryNotFoundException,
QueryAlreadyPersistedException, NotAllowedException {
- log.debug("endpoint persist query, container, containerId={}, databaseId={}, queryId={}, principal={}",
- containerId, databaseId, queryId, principal);
+ log.debug("endpoint persist query, container, databaseId={}, queryId={}, principal={}",
+ databaseId, queryId, principal);
/* check */
- endpointValidator.validateOnlyAccessOrPublic(containerId, databaseId, principal);
- final Query check = storeService.findOne(containerId, databaseId, queryId, principal);
+ endpointValidator.validateOnlyAccessOrPublic(databaseId, principal);
+ final Query check = storeService.findOne(databaseId, queryId, principal);
if (!check.getCreatedBy().equals(principal.getName())) {
log.error("Cannot persist foreign query: created by {}", check.getCreatedBy());
throw new NotAllowedException("Cannot persist foreign query: created by " + check.getCreatedBy());
@@ -257,7 +256,7 @@ public class StoreEndpoint {
/* has access */
accessService.find(databaseId, principal.getName());
/* persist */
- final Query query = storeService.persist(containerId, databaseId, queryId, principal);
+ final Query query = storeService.persist(databaseId, queryId, principal);
final QueryDto dto = queryMapper.queryToQueryDto(query);
final User creator = userService.findByUsername(query.getCreatedBy());
dto.setCreator(userMapper.userToUserDto(creator));
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableDataEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableDataEndpoint.java
index e0ad8ea8d8f59a8da425de67348db6e44472ea0f..758ab3be32860479839c8765ca67d7b9a991978e 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableDataEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableDataEndpoint.java
@@ -9,11 +9,14 @@ import at.tuwien.api.database.table.TableCsvUpdateDto;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
-import at.tuwien.service.*;
+import at.tuwien.service.DatabaseService;
+import at.tuwien.service.QueryService;
import at.tuwien.validation.EndpointValidator;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
@@ -21,15 +24,13 @@ import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
import java.time.Instant;
@Log4j2
@CrossOrigin(origins = "*")
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/table/{tableId}/data")
+@RequestMapping("/api/database/{databaseId}/table/{tableId}/data")
public class TableDataEndpoint {
private final QueryService queryService;
@@ -49,20 +50,19 @@ public class TableDataEndpoint {
@Timed(value = "data.insert", description = "Time needed to insert data into a table")
@PreAuthorize("hasAuthority('insert-table-data')")
@Operation(summary = "Insert data", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Void> insert(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Void> insert(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull @Valid @RequestBody TableCsvDto data,
@NotNull Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, TableMalformedException,
ImageNotSupportedException, ContainerNotFoundException, DatabaseConnectionException,
UserNotFoundException, NotAllowedException {
- log.debug("endpoint insert data, containerId={}, databaseId={}, tableId={}, data={}, principal={}", containerId,
+ log.debug("endpoint insert data, databaseId={}, tableId={}, data={}, principal={}",
databaseId, tableId, data, principal);
/* check */
- endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(containerId, databaseId, tableId, principal);
+ endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(databaseId, tableId, principal);
/* insert */
- queryService.insert(containerId, databaseId, tableId, data, principal);
+ queryService.insert(databaseId, tableId, data, principal);
return ResponseEntity.accepted()
.build();
}
@@ -73,20 +73,19 @@ public class TableDataEndpoint {
@PreAuthorize("hasAuthority('insert-table-data')")
@Timed(value = "data.update", description = "Time needed to update data in a table")
@Operation(summary = "Update data", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Void> update(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Void> update(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull @Valid @RequestBody TableCsvUpdateDto data,
@NotNull Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, TableMalformedException,
ImageNotSupportedException, DatabaseConnectionException, QueryMalformedException,
UserNotFoundException, NotAllowedException {
- log.debug("endpoint update data, containerId={}, databaseId={}, tableId={}, data={}, principal={}", containerId,
+ log.debug("endpoint update data, databaseId={}, tableId={}, data={}, principal={}",
databaseId, tableId, data, principal);
/* check */
- endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(containerId, databaseId, tableId, principal);
+ endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(databaseId, tableId, principal);
/* update */
- queryService.update(containerId, databaseId, tableId, data, principal);
+ queryService.update(databaseId, tableId, data, principal);
return ResponseEntity.accepted()
.build();
}
@@ -96,20 +95,19 @@ public class TableDataEndpoint {
@PreAuthorize("hasAuthority('delete-table-data')")
@Timed(value = "data.delete", description = "Time needed to delete data into a table")
@Operation(summary = "Delete data", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Void> delete(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Void> delete(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull @Valid @RequestBody TableCsvDeleteDto data,
@NotNull Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, TableMalformedException,
ImageNotSupportedException, ContainerNotFoundException,
DatabaseConnectionException, QueryMalformedException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint delete data, containerId={}, databaseId={}, tableId={}, data={}, principal={}", containerId,
+ log.debug("endpoint delete data, databaseId={}, tableId={}, data={}, principal={}",
databaseId, tableId, data, principal);
/* check */
- endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(containerId, databaseId, tableId, principal);
+ endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(databaseId, tableId, principal);
/* delete */
- queryService.delete(containerId, databaseId, tableId, data, principal);
+ queryService.delete(databaseId, tableId, data, principal);
return ResponseEntity.accepted()
.build();
}
@@ -119,20 +117,19 @@ public class TableDataEndpoint {
@PreAuthorize("hasAuthority('insert-table-data')")
@Timed(value = "data.insertbulk", description = "Time needed to insert data from .csv into a table")
@Operation(summary = "Insert data from csv", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Void> importCsv(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Void> importCsv(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull @Valid @RequestBody ImportDto data,
@NotNull Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, TableMalformedException,
ImageNotSupportedException, ContainerNotFoundException, DatabaseConnectionException,
QueryMalformedException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint insert data from csv, containerId={}, databaseId={}, tableId={}, data={}, principal={}",
- containerId, databaseId, tableId, data, principal);
+ log.debug("endpoint insert data from csv, databaseId={}, tableId={}, data={}, principal={}",
+ databaseId, tableId, data, principal);
/* check */
- endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(containerId, databaseId, tableId, principal);
+ endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(databaseId, tableId, principal);
/* insert */
- queryService.insert(containerId, databaseId, tableId, data, principal);
+ queryService.insert(databaseId, tableId, data, principal);
return ResponseEntity.accepted()
.build();
}
@@ -141,8 +138,7 @@ public class TableDataEndpoint {
@Transactional(readOnly = true)
@Timed(value = "data.all", description = "Time needed to find all data from a table")
@Operation(summary = "Find data", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<QueryResultDto> getAll(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryResultDto> getAll(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull Principal principal,
@RequestParam(required = false) Instant timestamp,
@@ -153,18 +149,18 @@ public class TableDataEndpoint {
throws TableNotFoundException, DatabaseNotFoundException, DatabaseConnectionException,
ImageNotSupportedException, TableMalformedException, PaginationException, ContainerNotFoundException,
QueryMalformedException, UserNotFoundException, SortException, NotAllowedException {
- log.debug("endpoint find table data, containerId={}, databaseId={}, tableId={}, principal={}, timestamp={}, page={}, size={}, sortDirection={}, sortColumn={}",
- containerId, databaseId, tableId, principal, timestamp, page, size, sortDirection, sortColumn);
+ log.debug("endpoint find table data, databaseId={}, tableId={}, principal={}, timestamp={}, page={}, size={}, sortDirection={}, sortColumn={}",
+ databaseId, tableId, principal, timestamp, page, size, sortDirection, sortColumn);
/* check */
endpointValidator.validateDataParams(page, size, sortDirection, sortColumn);
- endpointValidator.validateOnlyAccessOrPublic(containerId, databaseId, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ endpointValidator.validateOnlyAccessOrPublic(databaseId, principal);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic() && !User.hasRole(principal, "view-table-data")) {
log.error("Failed to view table data: database with id {} is private and user has no authority", databaseId);
throw new NotAllowedException("Failed to view table data: database with id " + databaseId + " is private and user has no authority");
}
/* find */
- final QueryResultDto response = queryService.tableFindAll(containerId, databaseId, tableId, timestamp, page, size, principal);
+ final QueryResultDto response = queryService.tableFindAll(databaseId, tableId, timestamp, page, size, principal);
log.trace("find table data resulted in result {}", response);
return ResponseEntity.ok()
.body(response);
@@ -174,25 +170,24 @@ public class TableDataEndpoint {
@Transactional(readOnly = true)
@Timed(value = "data.all.count", description = "Time needed to get count of all data from a table")
@Operation(summary = "Find data", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Long> getCount(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Long> getCount(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull Principal principal,
@RequestParam(required = false) Instant timestamp)
throws TableNotFoundException, DatabaseNotFoundException, DatabaseConnectionException,
ImageNotSupportedException, TableMalformedException, ContainerNotFoundException,
QueryStoreException, QueryMalformedException, UserNotFoundException, NotAllowedException {
- log.debug("endpoint find table data, containerId={}, databaseId={}, tableId={}, principal={}, timestamp={}",
- containerId, databaseId, tableId, principal, timestamp);
+ log.debug("endpoint find table data, databaseId={}, tableId={}, principal={}, timestamp={}",
+ databaseId, tableId, principal, timestamp);
/* check */
- endpointValidator.validateOnlyAccessOrPublic(containerId, databaseId, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ endpointValidator.validateOnlyAccessOrPublic(databaseId, principal);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic() && !User.hasRole(principal, "view-table-data")) {
log.error("Failed to view table data: database with id {} is private and user has no authority", databaseId);
throw new NotAllowedException("Failed to view table data: database with id " + databaseId + " is private and user has no authority");
}
/* find */
- final Long count = queryService.tableCount(containerId, databaseId, tableId, timestamp, principal);
+ final Long count = queryService.tableCount(databaseId, tableId, timestamp, principal);
log.debug("table data count is {} tuples", count);
return ResponseEntity.ok()
.body(count);
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableHistoryEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableHistoryEndpoint.java
index f0d05319d346b3e3664f609fd5763d93bdfbd388..05cf4553c72b5d6d108a4ff909407f3b08392a8b 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableHistoryEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/TableHistoryEndpoint.java
@@ -1,10 +1,9 @@
package at.tuwien.endpoint;
-import at.tuwien.api.database.table.TableBriefDto;
import at.tuwien.api.database.table.TableHistoryDto;
import at.tuwien.api.error.ApiErrorDto;
import at.tuwien.exception.*;
-import at.tuwien.service.*;
+import at.tuwien.service.TableService;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.ArraySchema;
@@ -13,20 +12,20 @@ import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
import java.util.List;
@Log4j2
@CrossOrigin(origins = "*")
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/table/{tableId}/history")
+@RequestMapping("/api/database/{databaseId}/table/{tableId}/history")
public class TableHistoryEndpoint {
private final TableService tableService;
@@ -72,15 +71,14 @@ public class TableHistoryEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<List<TableHistoryDto>> getAll(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<List<TableHistoryDto>> getAll(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("tableId") Long tableId,
@NotNull Principal principal)
throws TableNotFoundException, QueryMalformedException, DatabaseNotFoundException,
QueryStoreException, DatabaseConnectionException, UserNotFoundException {
- log.debug("endpoint find all history, containerId={}, databaseid={}, tableId={}, principal={}", containerId,
+ log.debug("endpoint find all history, databaseid={}, tableId={}, principal={}",
databaseId, tableId, principal);
- final List<TableHistoryDto> history = tableService.findHistory(containerId, databaseId, tableId, principal);
+ final List<TableHistoryDto> history = tableService.findHistory(databaseId, tableId, principal);
log.trace("find all history resulted in history {}", history);
return ResponseEntity.ok(history);
}
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ViewEndpoint.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ViewEndpoint.java
index a1149174e4c7df954d0c154523a6347d94960053..f52197744a3a674c3346e30fea8c4f26978edfe8 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ViewEndpoint.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/endpoint/ViewEndpoint.java
@@ -4,14 +4,15 @@ import at.tuwien.api.database.ViewBriefDto;
import at.tuwien.api.database.ViewCreateDto;
import at.tuwien.api.database.ViewDto;
import at.tuwien.api.database.query.QueryResultDto;
-import at.tuwien.api.database.table.TableBriefDto;
import at.tuwien.api.error.ApiErrorDto;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.database.View;
import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
import at.tuwien.mapper.ViewMapper;
-import at.tuwien.service.*;
+import at.tuwien.service.DatabaseService;
+import at.tuwien.service.QueryService;
+import at.tuwien.service.ViewService;
import at.tuwien.validation.EndpointValidator;
import io.micrometer.core.annotation.Timed;
import io.swagger.v3.oas.annotations.Operation;
@@ -21,6 +22,8 @@ import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
@@ -29,8 +32,6 @@ import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.NotNull;
import java.security.Principal;
import java.util.List;
import java.util.stream.Collectors;
@@ -38,7 +39,7 @@ import java.util.stream.Collectors;
@Log4j2
@CrossOrigin(origins = "*")
@RestController
-@RequestMapping("/api/container/{id}/database/{databaseId}/view")
+@RequestMapping("/api/database/{databaseId}/view")
public class ViewEndpoint {
private final ViewMapper viewMapper;
@@ -78,13 +79,12 @@ public class ViewEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<List<ViewBriefDto>> findAll(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<List<ViewBriefDto>> findAll(@NotNull @PathVariable("databaseId") Long databaseId,
Principal principal) throws DatabaseNotFoundException,
UserNotFoundException {
- log.debug("endpoint find all views, containerId={}, databaseId={}, principal={}", containerId,
+ log.debug("endpoint find all views, databaseId={}, principal={}",
databaseId, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
log.trace("find all views for database {}", database);
final List<ViewBriefDto> views = viewService.findAll(databaseId, principal)
.stream()
@@ -141,23 +141,22 @@ public class ViewEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<ViewBriefDto> create(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<ViewBriefDto> create(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @Valid @RequestBody ViewCreateDto data,
@NotNull Principal principal) throws DatabaseNotFoundException,
NotAllowedException, DatabaseConnectionException, ViewMalformedException, QueryMalformedException,
UserNotFoundException {
- log.debug("endpoint create view, containerId={}, databaseId={}, data={}, principal={}", containerId,
+ log.debug("endpoint create view, databaseId={}, data={}, principal={}",
databaseId, data, principal);
/* check */
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
if (!database.getOwner().equalsPrincipal(principal)) {
log.error("Failed to create view: not the database owner");
throw new NotAllowedException("Failed to create view: not the database owner");
}
log.trace("create view for database {}", database);
final View view;
- view = viewService.create(containerId, databaseId, data, principal);
+ view = viewService.create(databaseId, data, principal);
final ViewBriefDto dto = viewMapper.viewToViewBriefDto(view);
log.trace("create view resulted in view {}", dto);
return ResponseEntity.status(HttpStatus.CREATED)
@@ -185,14 +184,13 @@ public class ViewEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<ViewDto> find(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<ViewDto> find(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("viewId") Long viewId,
Principal principal) throws DatabaseNotFoundException,
NotAllowedException, ViewNotFoundException, UserNotFoundException {
- log.debug("endpoint find view, containerId={}, databaseId={}, viewId={}, principal={}", containerId,
+ log.debug("endpoint find view, databaseId={}, viewId={}, principal={}",
databaseId, viewId, principal);
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
log.trace("find view for database {}", database);
final ViewDto view = viewMapper.viewToViewDto(viewService.findById(databaseId, viewId, principal));
log.trace("find find resulted in view {}", view);
@@ -244,21 +242,20 @@ public class ViewEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<?> delete(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<?> delete(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("viewId") Long viewId,
@NotNull Principal principal) throws DatabaseNotFoundException,
ViewNotFoundException, UserNotFoundException, DatabaseConnectionException,
ViewMalformedException, QueryMalformedException, NotAllowedException {
- log.debug("endpoint delete view, containerId={}, databaseId={}, viewId={}, principal={}", containerId,
+ log.debug("endpoint delete view, databaseId={}, viewId={}, principal={}",
databaseId, viewId, principal);
/* check */
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
if (!database.getOwner().equalsPrincipal(principal)) {
log.error("Failed to delete view: not the database owner");
throw new NotAllowedException("Failed to delete view: not the database owner");
}
- viewService.delete(containerId, databaseId, viewId, principal);
+ viewService.delete(databaseId, viewId, principal);
return ResponseEntity.accepted()
.build();
}
@@ -324,8 +321,7 @@ public class ViewEndpoint {
mediaType = "application/json",
schema = @Schema(implementation = ApiErrorDto.class))}),
})
- public ResponseEntity<QueryResultDto> data(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<QueryResultDto> data(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("viewId") Long viewId,
Principal principal,
@RequestParam(required = false) Long page,
@@ -333,11 +329,11 @@ public class ViewEndpoint {
throws DatabaseNotFoundException, NotAllowedException, ViewNotFoundException, PaginationException,
QueryStoreException, DatabaseConnectionException, TableMalformedException, QueryMalformedException,
ImageNotSupportedException, ColumnParseException, UserNotFoundException, ContainerNotFoundException, ViewMalformedException {
- log.debug("endpoint find view data, containerId={}, databaseId={}, viewId={}, principal={}, page={}, size={}",
- containerId, databaseId, viewId, principal, page, size);
+ log.debug("endpoint find view data, databaseId={}, viewId={}, principal={}, page={}, size={}",
+ databaseId, viewId, principal, page, size);
/* check */
endpointValidator.validateDataParams(page, size);
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
if (!database.getIsPublic()) {
if (principal == null) {
log.error("Failed to view data of private view: principal is null");
@@ -351,7 +347,7 @@ public class ViewEndpoint {
/* find */
log.trace("find view data for database {}", database);
final View view = viewService.findById(databaseId, viewId, principal);
- final QueryResultDto result = queryService.viewFindAll(containerId, databaseId, view, page, size, principal);
+ final QueryResultDto result = queryService.viewFindAll(databaseId, view, page, size, principal);
log.trace("execute view {}", view);
log.trace("find view data resulted in result {}", result);
return ResponseEntity.ok()
@@ -362,20 +358,19 @@ public class ViewEndpoint {
@Transactional(readOnly = true)
@Timed(value = "view.data.count", description = "Time needed to retrieve data count from a view")
@Operation(summary = "Find view data count", security = @SecurityRequirement(name = "bearerAuth"))
- public ResponseEntity<Long> count(@NotNull @PathVariable("id") Long containerId,
- @NotNull @PathVariable("databaseId") Long databaseId,
+ public ResponseEntity<Long> count(@NotNull @PathVariable("databaseId") Long databaseId,
@NotNull @PathVariable("viewId") Long viewId,
Principal principal)
throws DatabaseNotFoundException, ViewNotFoundException, QueryStoreException, DatabaseConnectionException,
TableMalformedException, QueryMalformedException, ImageNotSupportedException, UserNotFoundException,
ContainerNotFoundException {
- log.debug("endpoint find view data count, containerId={}, databaseId={}, viewId={}, principal={}",
- containerId, databaseId, viewId, principal);
+ log.debug("endpoint find view data count, databaseId={}, viewId={}, principal={}",
+ databaseId, viewId, principal);
/* find */
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
log.trace("find view data for database {}", database);
final View view = viewService.findById(databaseId, viewId, principal);
- final Long result = queryService.viewCount(containerId, databaseId, view, principal);
+ final Long result = queryService.viewCount(databaseId, view, principal);
log.trace("execute view {}", view);
log.trace("find view data resulted in result {}", result);
return ResponseEntity.ok()
diff --git a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
index 435752f3088041e4d45f9d5a64abca0c0fe165c2..a3898b5a4fe2ae103a1adf8ea27feec17db88ed4 100644
--- a/dbrepo-query-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
+++ b/dbrepo-query-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
@@ -89,9 +89,9 @@ public class EndpointValidator {
throw new QueryMalformedException("Query contains forbidden keyword(s): " + Arrays.toString(words.toArray()));
}
- public void validateOnlyAccessOrPublic(Long containerId, Long databaseId, Principal principal)
+ public void validateOnlyAccessOrPublic(Long databaseId, Principal principal)
throws DatabaseNotFoundException, NotAllowedException {
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
if (database.getIsPublic()) {
log.trace("database with id {} is public: no access needed", databaseId);
return;
@@ -106,10 +106,10 @@ public class EndpointValidator {
log.trace("found access {}", access);
}
- public void validateOnlyWriteOwnOrWriteAllAccess(Long containerId, Long databaseId, Long tableId,
+ public void validateOnlyWriteOwnOrWriteAllAccess(Long databaseId, Long tableId,
Principal principal)
throws DatabaseNotFoundException, TableNotFoundException, NotAllowedException {
- final Table table = tableService.find(containerId, databaseId, tableId);
+ final Table table = tableService.find(databaseId, tableId);
if (principal == null) {
log.error("Access not allowed: no authorization provided");
throw new NotAllowedException("Access not allowed: no authorization provided");
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/config/MariaDbContainerConfig.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/config/MariaDbContainerConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..42e1d3b2bc700df0962a5864c5d6aac99c1a8c3a
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/config/MariaDbContainerConfig.java
@@ -0,0 +1,70 @@
+package at.tuwien.config;
+
+import at.tuwien.test.BaseTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.images.PullPolicy;
+
+/**
+ * This class configures the MariaDB container for the integration tests.
+ */
+@Configuration
+public class MariaDbContainerConfig {
+
+ public static CustomMariaDBContainer getContainer() {
+ return CustomMariaDBContainer.getInstance();
+ }
+
+ @Bean
+ public CustomMariaDBContainer mariaDB() {
+ return getContainer();
+ }
+
+ /**
+ * This class represents the customized MariaDB container. It is a singleton to avoid the recreation of containers
+ * which can be very time-consuming.
+ */
+ public static class CustomMariaDBContainer extends MariaDBContainer<CustomMariaDBContainer> {
+
+ private static CustomMariaDBContainer instance;
+
+ private boolean started = false;
+
+ public static synchronized CustomMariaDBContainer getInstance() {
+ if(instance == null) {
+ instance = new CustomMariaDBContainer(BaseTest.IMAGE_1_NAME + ":" + BaseTest.IMAGE_1_VERSION);
+ instance.withImagePullPolicy(PullPolicy.alwaysPull());
+ instance.addFixedExposedPort(BaseTest.CONTAINER_1_PORT, BaseTest.IMAGE_1_PORT);
+ instance.withUsername(BaseTest.CONTAINER_1_PRIVILEGED_USERNAME);
+ instance.withPassword(BaseTest.CONTAINER_1_PRIVILEGED_PASSWORD);
+ instance.withInitScript("init/users.sql");
+ instance.withFileSystemBind("/tmp", "/tmp");
+ }
+ return instance;
+ }
+
+ private CustomMariaDBContainer(String dockerImageName) {
+ super(dockerImageName);
+ }
+
+ @Override
+ protected void configure() {
+ super.configure();
+ this.addEnv("MYSQL_USER", "test"); // MariaDB does not allow this to be root
+ }
+
+ @Override
+ public synchronized void start() {
+ if(!started) {
+ super.start();
+ started = true;
+ }
+ }
+
+ @Override
+ public void stop() {
+ // do nothing, JVM handles shut down
+ }
+ }
+}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ExportEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ExportEndpointUnitTest.java
index 2fc48f70c83a3dffd308be4bdf7ab411fb8a730f..f2532f761229f39c8af1ff188725dd5a096595c6 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ExportEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ExportEndpointUnitTest.java
@@ -37,7 +37,7 @@ import java.time.temporal.ChronoUnit;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.when;
@Log4j2
@SpringBootTest
@@ -83,7 +83,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- export_generic(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, null, null, null);
+ export_generic(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, null, null, null);
});
}
@@ -95,7 +95,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
UserNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, USER_1_PRINCIPAL, USER_1_USERNAME, null);
+ export_generic(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, USER_1_PRINCIPAL, USER_1_USERNAME, null);
}
@Test
@@ -106,7 +106,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
UserNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, USER_1_PRINCIPAL, USER_1_USERNAME, DATABASE_1_USER_1_READ_ACCESS);
+ export_generic(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, null, USER_1_PRINCIPAL, USER_1_USERNAME, DATABASE_1_USER_1_READ_ACCESS);
}
@Test
@@ -116,7 +116,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- export_generic(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, timestamp, null, null, null);
+ export_generic(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, timestamp, null, null, null);
});
}
@@ -126,7 +126,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- export_generic(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, timestamp, null, null, null);
+ export_generic(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, timestamp, null, null, null);
});
}
@@ -140,7 +140,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, null, null, null);
+ export_generic(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, null, null, null);
});
}
@@ -152,7 +152,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
UserNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, USER_2_PRINCIPAL, USER_2_USERNAME, null);
+ export_generic(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, USER_2_PRINCIPAL, USER_2_USERNAME, null);
}
@Test
@@ -163,7 +163,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
UserNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_WRITE_OWN_ACCESS);
+ export_generic(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, null, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_WRITE_OWN_ACCESS);
}
@Test
@@ -175,7 +175,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
final Instant timestamp = Instant.now();
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, timestamp, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_READ_ACCESS);
+ export_generic(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, timestamp, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -187,14 +187,14 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
final Instant timestamp = Instant.now().plus(10, ChronoUnit.DAYS);
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, timestamp, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_READ_ACCESS);
+ export_generic(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, timestamp, USER_2_PRINCIPAL, USER_2_USERNAME, DATABASE_2_USER_1_READ_ACCESS);
}
/* ################################################################################################### */
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- protected void export_generic(Long containerId, Long databaseId, Long tableId, Database database, Instant timestamp,
+ protected void export_generic(Long databaseId, Long tableId, Database database, Instant timestamp,
Principal principal, String username, DatabaseAccess access) throws IOException,
DatabaseNotFoundException, UserNotFoundException, TableNotFoundException, DatabaseConnectionException,
TableMalformedException, QueryMalformedException, ImageNotSupportedException, FileStorageException,
@@ -205,7 +205,7 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access == null) {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
@@ -214,13 +214,13 @@ public class ExportEndpointUnitTest extends BaseUnitTest {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
.thenReturn(Optional.of(access));
}
- when(tableRepository.find(containerId, databaseId, tableId))
+ when(tableRepository.find(databaseId, tableId))
.thenReturn(Optional.of(TABLE_1));
- when(queryService.tableFindAll(containerId, databaseId, tableId, timestamp, principal))
+ when(queryService.tableFindAll(databaseId, tableId, timestamp, principal))
.thenReturn(resource);
/* test */
- final ResponseEntity<InputStreamResource> response = exportEndpoint.export(containerId, databaseId, tableId,
+ final ResponseEntity<InputStreamResource> response = exportEndpoint.export(databaseId, tableId,
timestamp, principal);
assertNotNull(response);
assertEquals(HttpStatus.OK, response.getStatusCode());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/QueryEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/QueryEndpointUnitTest.java
index e9b3371a748ec4884b0662263805e55b096004d4..ea03aca6e40b0946a861095c4a60e8ec8f9a6bc6 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/QueryEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/QueryEndpointUnitTest.java
@@ -95,7 +95,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(QueryMalformedException.class, () -> {
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, statement, null, USER_2_PRINCIPAL, DATABASE_3, null);
+ generic_execute(DATABASE_3_ID, statement, null, USER_2_PRINCIPAL, DATABASE_3, null);
});
}
@@ -106,7 +106,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(QueryMalformedException.class, () -> {
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, statement, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_READ_ACCESS);
+ generic_execute(DATABASE_3_ID, statement, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_READ_ACCESS);
});
}
@@ -117,7 +117,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(QueryMalformedException.class, () -> {
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, statement, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_READ_ACCESS);
+ generic_execute(DATABASE_3_ID, statement, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_READ_ACCESS);
});
}
@@ -128,7 +128,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(QueryMalformedException.class, () -> {
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, statement, null, USER_2_PRINCIPAL, DATABASE_3, null);
+ generic_execute(DATABASE_3_ID, statement, null, USER_2_PRINCIPAL, DATABASE_3, null);
});
}
@@ -138,7 +138,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_STATEMENT, null, null, DATABASE_3, null);
+ generic_execute(DATABASE_3_ID, QUERY_4_STATEMENT, null, null, DATABASE_3, null);
});
}
@@ -150,7 +150,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
}
@Test
@@ -161,7 +161,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
}
@Test
@@ -172,7 +172,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
}
@Test
@@ -183,7 +183,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_3_ID, QUERY_4_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_2_WRITE_ALL_ACCESS);
}
@Test
@@ -194,7 +194,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_reExecute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
+ generic_reExecute(DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
null, null, DATABASE_3, null);
}
@@ -206,7 +206,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException, QueryNotFoundException {
/* test */
- generic_reExecute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
+ generic_reExecute(DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_READ_ACCESS);
}
@@ -218,7 +218,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException, QueryNotFoundException {
/* test */
- generic_reExecute(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
+ generic_reExecute(DATABASE_3_ID, QUERY_4_ID, QUERY_4, QUERY_4_RESULT_ID, QUERY_4_RESULT_DTO,
USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_WRITE_OWN_ACCESS);
}
@@ -230,7 +230,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException, NotAllowedException {
/* test */
- export_generic(CONTAINER_3_ID, DATABASE_3_ID, QUERY_3_ID, null, null, DATABASE_3, null, null, HttpStatus.OK);
+ export_generic(DATABASE_3_ID, QUERY_3_ID, null, null, DATABASE_3, null, null, HttpStatus.OK);
}
@Test
@@ -238,7 +238,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
public void export_publicAnonymizedInvalidFormat_fails() throws UserNotFoundException, QueryStoreException, DatabaseConnectionException, TableMalformedException, NotAllowedException, QueryMalformedException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException, IOException, FileStorageException, ContainerNotFoundException {
/* test */
- export_generic(CONTAINER_3_ID, DATABASE_3_ID, QUERY_3_ID, null, null, DATABASE_3, null, "application/json", HttpStatus.NOT_IMPLEMENTED);
+ export_generic(DATABASE_3_ID, QUERY_3_ID, null, null, DATABASE_3, null, "application/json", HttpStatus.NOT_IMPLEMENTED);
}
@Test
@@ -249,7 +249,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException, NotAllowedException {
/* test */
- export_generic(CONTAINER_3_ID, DATABASE_3_ID, QUERY_3_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_READ_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_3_ID, QUERY_3_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_READ_ACCESS, null, HttpStatus.OK);
}
@Test
@@ -260,7 +260,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException, NotAllowedException {
/* test */
- export_generic(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_WRITE_OWN_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_3_ID, QUERY_4_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_WRITE_OWN_ACCESS, null, HttpStatus.OK);
}
@Test
@@ -271,7 +271,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException, NotAllowedException {
/* test */
- export_generic(CONTAINER_3_ID, DATABASE_3_ID, QUERY_4_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_WRITE_ALL_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_3_ID, QUERY_4_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3, DATABASE_3_USER_1_WRITE_ALL_ACCESS, null, HttpStatus.OK);
}
/* ################################################################################################### */
@@ -285,7 +285,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_execute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_STATEMENT, null, principal, DATABASE_2, null);
+ generic_execute(DATABASE_2_ID, QUERY_1_STATEMENT, null, principal, DATABASE_2, null);
});
}
@@ -297,7 +297,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_READ_ACCESS);
+ generic_execute(DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -308,7 +308,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_OWN_ACCESS);
+ generic_execute(DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_OWN_ACCESS);
}
@Test
@@ -319,7 +319,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_2_ID, QUERY_1_STATEMENT, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS);
}
@Test
@@ -330,7 +330,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException {
/* test */
- generic_execute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_STATEMENT, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS);
+ generic_execute(DATABASE_2_ID, QUERY_1_STATEMENT, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS);
}
@Test
@@ -339,7 +339,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- generic_reExecute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
+ generic_reExecute(DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
null, null, DATABASE_2, null);
});
}
@@ -352,7 +352,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException, QueryNotFoundException {
/* test */
- generic_reExecute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
+ generic_reExecute(DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_READ_ACCESS);
}
@@ -364,7 +364,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException, QueryNotFoundException {
/* test */
- generic_reExecute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
+ generic_reExecute(DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_OWN_ACCESS);
}
@@ -376,7 +376,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
PaginationException, QueryNotFoundException {
/* test */
- generic_reExecute(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
+ generic_reExecute(DATABASE_2_ID, QUERY_1_ID, QUERY_1, QUERY_1_RESULT_ID, QUERY_1_RESULT_DTO,
USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS);
}
@@ -386,7 +386,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, null, null, DATABASE_2, null, null, HttpStatus.OK);
+ export_generic(DATABASE_2_ID, QUERY_1_ID, null, null, DATABASE_2, null, null, HttpStatus.OK);
});
}
@@ -395,7 +395,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
public void export_privateInvalidFormat_fails() throws UserNotFoundException, QueryStoreException, DatabaseConnectionException, TableMalformedException, NotAllowedException, QueryMalformedException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException, IOException, FileStorageException, ContainerNotFoundException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_2_READ_ACCESS, "application/json", HttpStatus.NOT_IMPLEMENTED);
+ export_generic(DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_2_READ_ACCESS, "application/json", HttpStatus.NOT_IMPLEMENTED);
}
@Test
@@ -406,7 +406,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_READ_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_READ_ACCESS, null, HttpStatus.OK);
}
@Test
@@ -417,7 +417,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_OWN_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_OWN_ACCESS, null, HttpStatus.OK);
}
@Test
@@ -428,14 +428,14 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, IOException {
/* test */
- export_generic(CONTAINER_2_ID, DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS, null, HttpStatus.OK);
+ export_generic(DATABASE_2_ID, QUERY_1_ID, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2, DATABASE_2_USER_1_WRITE_ALL_ACCESS, null, HttpStatus.OK);
}
/* ################################################################################################### */
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- protected void generic_execute(Long containerId, Long databaseId, String statement, String username,
+ protected void generic_execute(Long databaseId, String statement, String username,
Principal principal, Database database, DatabaseAccess access)
throws UserNotFoundException, QueryStoreException, TableMalformedException, DatabaseConnectionException,
QueryMalformedException, ColumnParseException, DatabaseNotFoundException, ImageNotSupportedException,
@@ -449,9 +449,9 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
final String sortColumn = "location";
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(containerId, databaseId))
+ when(databaseRepository.findByDatabaseId(databaseId))
.thenReturn(Optional.of(database));
- log.trace("mock database for container with id {} and database id {}", containerId, databaseId);
+ log.trace("mock database for container database id {}", databaseId);
if (access == null) {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
.thenReturn(Optional.empty());
@@ -461,12 +461,12 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
.thenReturn(Optional.of(access));
log.trace("mock access {} for database with id {} and username {}", access.getType(), databaseId, username);
}
- when(queryService.execute(containerId, databaseId, request, principal, page, size, sortDirection, sortColumn))
+ when(queryService.execute(databaseId, request, principal, page, size, sortDirection, sortColumn))
.thenReturn(QUERY_1_RESULT_DTO);
- log.trace("mock query service for container with id {} and database with id {}", containerId, databaseId);
+ log.trace("mock query service for container database with id {}", databaseId);
/* test */
- final ResponseEntity<QueryResultDto> response = queryEndpoint.execute(containerId, databaseId, request,
+ final ResponseEntity<QueryResultDto> response = queryEndpoint.execute(databaseId, request,
page, size, principal, sortDirection, sortColumn);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
assertNotNull(response.getBody());
@@ -476,7 +476,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
assertEquals(QUERY_1_RESULT_RESULT, response.getBody().getResult());
}
- protected void generic_reExecute(Long containerId, Long databaseId, Long queryId, Query query, Long resultId,
+ protected void generic_reExecute(Long databaseId, Long queryId, Query query, Long resultId,
QueryResultDto result, String username, Principal principal, Database database,
DatabaseAccess access)
throws UserNotFoundException, QueryStoreException, DatabaseConnectionException, QueryNotFoundException,
@@ -488,9 +488,9 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
final String sortColumn = "location";
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(containerId, databaseId))
+ when(databaseRepository.findByDatabaseId(databaseId))
.thenReturn(Optional.of(database));
- when(storeService.findOne(containerId, databaseId, queryId, principal))
+ when(storeService.findOne(databaseId, queryId, principal))
.thenReturn(query);
if (access == null) {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
@@ -499,18 +499,18 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
.thenReturn(Optional.of(access));
}
- when(queryService.reExecute(containerId, databaseId, query, page, size, sortDirection, sortColumn, principal))
+ when(queryService.reExecute(databaseId, query, page, size, sortDirection, sortColumn, principal))
.thenReturn(result);
/* test */
- final ResponseEntity<QueryResultDto> response = queryEndpoint.reExecute(containerId, databaseId, queryId,
+ final ResponseEntity<QueryResultDto> response = queryEndpoint.reExecute(databaseId, queryId,
principal, page, size, sortDirection, sortColumn);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
assertNotNull(response.getBody());
assertEquals(resultId, response.getBody().getId());
}
- protected void export_generic(Long containerId, Long databaseId, Long queryId, String username, Principal principal,
+ protected void export_generic(Long databaseId, Long queryId, String username, Principal principal,
Database database, DatabaseAccess access, String accept, HttpStatus status) throws IOException,
UserNotFoundException, QueryStoreException, DatabaseConnectionException, QueryNotFoundException,
DatabaseNotFoundException, ImageNotSupportedException, TableMalformedException, QueryMalformedException,
@@ -521,7 +521,7 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(containerId, databaseId))
+ when(databaseRepository.findByDatabaseId(databaseId))
.thenReturn(Optional.of(database));
if (access == null) {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
@@ -530,13 +530,13 @@ public class QueryEndpointUnitTest extends BaseUnitTest {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
.thenReturn(Optional.of(access));
}
- when(storeService.findOne(containerId, databaseId, queryId, principal))
+ when(storeService.findOne(databaseId, queryId, principal))
.thenReturn(QUERY_1);
- when(queryService.findOne(containerId, databaseId, queryId, principal))
+ when(queryService.findOne(databaseId, queryId, principal))
.thenReturn(resource);
/* test */
- final ResponseEntity<?> response = queryEndpoint.export(containerId, databaseId, queryId, accept, principal);
+ final ResponseEntity<?> response = queryEndpoint.export(databaseId, queryId, accept, principal);
assertEquals(status, response.getStatusCode());
if (status.equals(HttpStatus.OK)) {
assertNotNull(response.getBody());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/StoreEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/StoreEndpointUnitTest.java
index e4d98d80443fd800b39b7f924461f1597558527d..72967d0e444b00709599137d3d46207fe75c1cca 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/StoreEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/StoreEndpointUnitTest.java
@@ -81,7 +81,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, null);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, null);
});
}
@@ -91,7 +91,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, DatabaseConnectionException, TableMalformedException, UserNotFoundException, NotAllowedException {
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, null);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, null);
}
@Test
@@ -100,7 +100,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, DatabaseConnectionException, TableMalformedException, UserNotFoundException, NotAllowedException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_1_PRINCIPAL);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_1_PRINCIPAL);
}
@Test
@@ -109,7 +109,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, DatabaseConnectionException, TableMalformedException, UserNotFoundException, NotAllowedException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_1_PRINCIPAL);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_1_PRINCIPAL);
}
@Test
@@ -123,7 +123,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_PRINCIPAL);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_2_PRINCIPAL);
});
}
@@ -139,7 +139,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
.find(DATABASE_3_ID, USER_2_USERNAME);
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_PRINCIPAL);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, USER_2_PRINCIPAL);
}
@Test
@@ -153,7 +153,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
.thenReturn(DATABASE_1_USER_1_READ_ACCESS);
/* test */
- findAll_generic(CONTAINER_2_ID, DATABASE_2_ID, DATABASE_2, USER_1_PRINCIPAL);
+ findAll_generic(DATABASE_2_ID, DATABASE_2, USER_1_PRINCIPAL);
}
@Test
@@ -166,7 +166,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryDto response = find_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, QUERY_4_ID, QUERY_4, null, null, null);
+ final QueryDto response = find_generic(DATABASE_3_ID, DATABASE_3, QUERY_4_ID, QUERY_4, null, null, null);
assertEquals(QUERY_4_ID, response.getId());
assertEquals(QUERY_4_STATEMENT, response.getQuery());
}
@@ -181,7 +181,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, null, null, null);
+ find_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, null, null, null);
});
}
@@ -191,7 +191,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, UserNotFoundException, NotAllowedException, DatabaseConnectionException {
/* test */
- final QueryDto response = find_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
+ final QueryDto response = find_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
assertEquals(QUERY_1_ID, response.getId());
assertEquals(QUERY_1_STATEMENT, response.getQuery());
}
@@ -202,7 +202,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, UserNotFoundException, NotAllowedException, DatabaseConnectionException {
/* test */
- final QueryDto response = find_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
+ final QueryDto response = find_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
assertEquals(QUERY_1_ID, response.getId());
assertEquals(QUERY_1_STATEMENT, response.getQuery());
}
@@ -213,7 +213,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(QueryNotFoundException.class, () -> {
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, null, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
+ find_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, null, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
});
}
@@ -223,7 +223,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(DatabaseNotFoundException.class, () -> {
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, null, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
+ find_generic(DATABASE_1_ID, null, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL);
});
}
@@ -234,7 +234,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ImageNotSupportedException {
/* test */
- final QueryDto response = persist_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_READ_ACCESS);
+ final QueryDto response = persist_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_READ_ACCESS);
assertEquals(QUERY_1_ID, response.getId());
assertEquals(QUERY_1_STATEMENT, response.getQuery());
}
@@ -246,7 +246,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ImageNotSupportedException {
/* test */
- final QueryDto response = persist_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_OWN_ACCESS);
+ final QueryDto response = persist_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_OWN_ACCESS);
assertEquals(QUERY_1_ID, response.getId());
assertEquals(QUERY_1_STATEMENT, response.getQuery());
}
@@ -258,7 +258,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ImageNotSupportedException {
/* test */
- final QueryDto response = persist_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_ALL_ACCESS);
+ final QueryDto response = persist_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_1_USERNAME, USER_1, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_ALL_ACCESS);
assertEquals(QUERY_1_ID, response.getId());
assertEquals(QUERY_1_STATEMENT, response.getQuery());
}
@@ -273,7 +273,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- persist_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_2_USERNAME, USER_2, USER_2_PRINCIPAL, DATABASE_1_USER_2_WRITE_ALL_ACCESS);
+ persist_generic(DATABASE_1_ID, DATABASE_1, QUERY_1_ID, QUERY_1, USER_2_USERNAME, USER_2, USER_2_PRINCIPAL, DATABASE_1_USER_2_WRITE_ALL_ACCESS);
});
}
@@ -282,18 +282,18 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- protected QueryDto persist_generic(Long containerId, Long databaseId, Database database, Long queryId, Query query,
+ protected QueryDto persist_generic(Long databaseId, Database database, Long queryId, Query query,
String username, User user, Principal principal, DatabaseAccess access)
throws DatabaseNotFoundException, UserNotFoundException, QueryStoreException, QueryNotFoundException,
ImageNotSupportedException, NotAllowedException, DatabaseConnectionException,
QueryAlreadyPersistedException {
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
- when(storeService.findOne(containerId, databaseId, queryId, principal))
+ when(storeService.findOne(databaseId, queryId, principal))
.thenReturn(query);
- when(storeService.persist(containerId, databaseId, queryId, principal))
+ when(storeService.persist(databaseId, queryId, principal))
.thenReturn(query);
if (access != null) {
log.trace("mock access for database with id {} and username {}", databaseId, username);
@@ -308,24 +308,24 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
.thenReturn(Optional.of(user));
/* test */
- final ResponseEntity<QueryDto> response = storeEndpoint.persist(containerId, databaseId, queryId, principal);
+ final ResponseEntity<QueryDto> response = storeEndpoint.persist(databaseId, queryId, principal);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
assertNotNull(response.getBody());
return response.getBody();
}
- protected void findAll_generic(Long containerId, Long databaseId, Database database, Principal principal)
+ protected void findAll_generic(Long databaseId, Database database, Principal principal)
throws UserNotFoundException, QueryStoreException, DatabaseConnectionException, TableMalformedException,
DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, NotAllowedException {
/* mock */
doReturn(List.of(QUERY_1)).when(storeService)
- .findAll(containerId, databaseId, true, principal);
- when(databaseService.find(containerId, databaseId))
+ .findAll(databaseId, true, principal);
+ when(databaseService.find(databaseId))
.thenReturn(database);
/* test */
- final ResponseEntity<List<QueryBriefDto>> response = storeEndpoint.findAll(containerId, databaseId, true, principal);
+ final ResponseEntity<List<QueryBriefDto>> response = storeEndpoint.findAll(databaseId, true, principal);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
assertEquals(1, response.getBody().size());
@@ -334,24 +334,24 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
assertEquals(QUERY_1_STATEMENT, query.getQuery());
}
- protected QueryDto find_generic(Long containerId, Long databaseId, Database database, Long queryId, Query query,
+ protected QueryDto find_generic(Long databaseId, Database database, Long queryId, Query query,
String username, User user, Principal principal) throws QueryStoreException,
QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException, UserNotFoundException,
NotAllowedException, DatabaseConnectionException {
/* mock */
if (query != null) {
- when(storeService.findOne(containerId, databaseId, queryId, principal))
+ when(storeService.findOne(databaseId, queryId, principal))
.thenReturn(query);
} else {
- when(storeService.findOne(containerId, databaseId, queryId, principal))
+ when(storeService.findOne(databaseId, queryId, principal))
.thenThrow(QueryNotFoundException.class);
}
if (database != null) {
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
} else {
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenThrow(DatabaseNotFoundException.class);
}
if (user != null) {
@@ -363,7 +363,7 @@ public class StoreEndpointUnitTest extends BaseUnitTest {
}
/* test */
- final ResponseEntity<QueryDto> response = storeEndpoint.find(containerId, databaseId, queryId, principal);
+ final ResponseEntity<QueryDto> response = storeEndpoint.find(databaseId, queryId, principal);
assertEquals(HttpStatus.OK, response.getStatusCode());
final QueryDto body = response.getBody();
assertNotNull(body);
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableDataEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableDataEndpointUnitTest.java
index 0374aae586a6649c8e4570c503bd828fd41a8451..7974925bb0038cff002890cea62ff8f6b0928164 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableDataEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableDataEndpointUnitTest.java
@@ -12,7 +12,6 @@ import at.tuwien.entities.database.DatabaseAccess;
import at.tuwien.entities.database.table.Table;
import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
-import at.tuwien.listener.MessageQueueListener;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
import at.tuwien.repository.sdb.ViewIdxRepository;
import at.tuwien.service.AccessService;
@@ -41,7 +40,7 @@ import java.time.Instant;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.when;
@Log4j2
@SpringBootTest
@@ -87,7 +86,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
+ generic_import(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
});
}
@@ -97,7 +96,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
+ generic_import(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
DATABASE_1_USER_1_READ_ACCESS, USER_2_PRINCIPAL);
});
}
@@ -108,7 +107,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
+ generic_import(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
DATABASE_1_USER_1_WRITE_OWN_ACCESS, USER_2_PRINCIPAL);
});
}
@@ -119,7 +118,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_2_ID, DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, null, null, null);
+ generic_import(DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, null, null, null);
});
}
@@ -129,7 +128,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_2_ID, DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
+ generic_import(DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
DATABASE_2_USER_1_READ_ACCESS, USER_2_PRINCIPAL);
});
}
@@ -140,7 +139,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_2_ID, DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
+ generic_import(DATABASE_2_ID, DATABASE_2, TABLE_1_ID, TABLE_1, USER_2_USERNAME,
DATABASE_2_USER_1_WRITE_OWN_ACCESS, USER_2_PRINCIPAL);
});
}
@@ -151,7 +150,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_import(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, TABLE_8_ID, TABLE_8, null, null, null);
+ generic_import(DATABASE_3_ID, DATABASE_3, TABLE_8_ID, TABLE_8, null, null, null);
});
}
@@ -162,7 +161,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, ContainerNotFoundException {
/* test */
- generic_import(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, TABLE_8_ID, TABLE_8, USER_1_USERNAME,
+ generic_import(DATABASE_3_ID, DATABASE_3, TABLE_8_ID, TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_ALL_ACCESS, USER_1_PRINCIPAL);
}
@@ -173,7 +172,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, ContainerNotFoundException {
/* test */
- generic_import(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_1_USERNAME,
+ generic_import(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_1_USERNAME,
DATABASE_1_USER_1_WRITE_ALL_ACCESS, USER_1_PRINCIPAL);
}
@@ -183,7 +182,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME, null,
+ generic_insert(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME, null,
TABLE_1_CSV_DTO, null);
});
}
@@ -194,7 +193,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME,
+ generic_insert(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME,
DATABASE_1_USER_1_READ_ACCESS, TABLE_1_CSV_DTO, USER_2_PRINCIPAL);
});
}
@@ -205,7 +204,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME,
+ generic_insert(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_2_USERNAME,
DATABASE_1_USER_1_WRITE_OWN_ACCESS, TABLE_1_CSV_DTO, USER_2_PRINCIPAL);
});
}
@@ -216,7 +215,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME, null,
+ generic_insert(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME, null,
TABLE_1_CSV_DTO, null);
});
}
@@ -227,7 +226,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME,
+ generic_insert(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME,
DATABASE_2_USER_1_READ_ACCESS, TABLE_1_CSV_DTO, USER_2_PRINCIPAL);
});
}
@@ -238,7 +237,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- generic_insert(CONTAINER_2_ID, DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME,
+ generic_insert(DATABASE_2_ID, TABLE_1_ID, DATABASE_2, TABLE_1, USER_2_USERNAME,
DATABASE_2_USER_1_WRITE_OWN_ACCESS, TABLE_1_CSV_DTO, USER_2_PRINCIPAL);
});
}
@@ -250,7 +249,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, ContainerNotFoundException {
/* test */
- generic_insert(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, USER_1_USERNAME,
+ generic_insert(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_ALL_ACCESS, TABLE_8_CSV_DTO, USER_1_PRINCIPAL);
}
@@ -261,7 +260,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, ContainerNotFoundException {
/* test */
- generic_insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_1_USERNAME,
+ generic_insert(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_1_USERNAME,
DATABASE_1_USER_1_WRITE_ALL_ACCESS, TABLE_1_CSV_DTO, USER_1_PRINCIPAL);
}
@@ -272,7 +271,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
ImageNotSupportedException, ContainerNotFoundException {
/* test */
- generic_insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_1_USERNAME,
+ generic_insert(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_1_USERNAME,
DATABASE_1_USER_1_WRITE_ALL_ACCESS, null, USER_1_PRINCIPAL);
}
@@ -282,7 +281,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(PaginationException.class, () -> {
- generic_getAll(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, null,
+ generic_getAll(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, null,
3L, null, null);
});
}
@@ -293,7 +292,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(PaginationException.class, () -> {
- generic_getAll(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 3L,
+ generic_getAll(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 3L,
null, null, null);
});
}
@@ -304,7 +303,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(PaginationException.class, () -> {
- generic_getAll(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, -3L,
+ generic_getAll(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, -3L,
3L, null, null);
});
}
@@ -315,7 +314,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(PaginationException.class, () -> {
- generic_getAll(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 3L,
+ generic_getAll(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 3L,
-3L, null, null);
});
}
@@ -326,7 +325,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(PaginationException.class, () -> {
- generic_getAll(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 0L,
+ generic_getAll(DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8, null, null, null, null, 0L,
0L, null, null);
});
}
@@ -337,7 +336,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- generic_getAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, null, null, null, null, null, null, null, null);
+ generic_getAll(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, null, null, null, null, null, null, null, null);
});
}
@@ -347,7 +346,7 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- generic_getAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_4_USERNAME, DATABASE_1_USER_1_READ_ACCESS, USER_4_PRINCIPAL, null, null, null, null, null);
+ generic_getAll(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_4_USERNAME, DATABASE_1_USER_1_READ_ACCESS, USER_4_PRINCIPAL, null, null, null, null, null);
});
}
@@ -357,31 +356,31 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- generic_getCount(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_4_USERNAME, DATABASE_1_USER_1_READ_ACCESS, USER_4_PRINCIPAL, null);
+ generic_getCount(DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1, USER_4_USERNAME, DATABASE_1_USER_1_READ_ACCESS, USER_4_PRINCIPAL, null);
});
}
public static Stream<Arguments> getAll_succeeds_parameters() {
return Stream.of(
- Arguments.arguments("public anonymous", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public anonymous", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, null, null, null,
null, null, null, null, null),
- Arguments.arguments("public read", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8,
+ Arguments.arguments("public read", DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8,
USER_1_USERNAME,
DATABASE_3_USER_1_READ_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null),
- Arguments.arguments("public write-own", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public write-own", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_OWN_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null),
- Arguments.arguments("public write-all", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public write-all", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_ALL_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null),
- Arguments.arguments("private read", CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1,
+ Arguments.arguments("private read", DATABASE_1_ID, TABLE_1_ID, DATABASE_1, TABLE_1,
USER_1_USERNAME,
DATABASE_1_USER_1_READ_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null),
- Arguments.arguments("private write-own", CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1,
+ Arguments.arguments("private write-own", DATABASE_1_ID, TABLE_1_ID, DATABASE_1,
TABLE_1, USER_1_USERNAME,
DATABASE_1_USER_1_WRITE_OWN_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null),
- Arguments.arguments("private write-all", CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, DATABASE_1,
+ Arguments.arguments("private write-all", DATABASE_1_ID, TABLE_1_ID, DATABASE_1,
TABLE_1, USER_1_USERNAME,
DATABASE_1_USER_1_WRITE_ALL_ACCESS, USER_1_PRINCIPAL, null, null, null, null, null)
);
@@ -390,35 +389,35 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
@ParameterizedTest
@WithMockUser(username = USER_1_USERNAME, authorities = {"insert-table-data"})
@MethodSource("getAll_succeeds_parameters")
- public void getAll_succeeds(String test, Long containerId, Long databaseId, Long tableId, Database database,
+ public void getAll_succeeds(String test, Long databaseId, Long tableId, Database database,
Table table, String username, DatabaseAccess access, Principal principal,
Instant timestamp, Long page, Long size, SortType sortDirection, String sortColumn) throws UserNotFoundException, TableNotFoundException, QueryStoreException, SortException, TableMalformedException, NotAllowedException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, PaginationException, ContainerNotFoundException {
/* test */
- generic_getAll(containerId, databaseId, tableId, database, table, username, access, principal, timestamp,
+ generic_getAll(databaseId, tableId, database, table, username, access, principal, timestamp,
page, size, sortDirection, sortColumn);
}
public static Stream<Arguments> getCount_succeeds_parameters() {
return Stream.of(
- Arguments.arguments("public anonymous", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public anonymous", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, null, null, null, null),
- Arguments.arguments("public read", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8,
+ Arguments.arguments("public read", DATABASE_3_ID, TABLE_8_ID, DATABASE_3, TABLE_8,
USER_1_USERNAME,
DATABASE_3_USER_1_READ_ACCESS, USER_1_PRINCIPAL, null),
- Arguments.arguments("public write-own", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public write-own", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_OWN_ACCESS, USER_1_PRINCIPAL, null),
- Arguments.arguments("public write-all", CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
+ Arguments.arguments("public write-all", DATABASE_3_ID, TABLE_8_ID, DATABASE_3,
TABLE_8, USER_1_USERNAME,
DATABASE_3_USER_1_WRITE_ALL_ACCESS, USER_1_PRINCIPAL, null),
- Arguments.arguments("private read", CONTAINER_1_ID, DATABASE_2_ID, TABLE_8_ID, DATABASE_2, TABLE_8,
+ Arguments.arguments("private read", DATABASE_2_ID, TABLE_8_ID, DATABASE_2, TABLE_8,
USER_1_USERNAME,
DATABASE_2_USER_1_READ_ACCESS, USER_1_PRINCIPAL, null),
- Arguments.arguments("private write-own", CONTAINER_1_ID, DATABASE_2_ID, TABLE_8_ID, DATABASE_2,
+ Arguments.arguments("private write-own", DATABASE_2_ID, TABLE_8_ID, DATABASE_2,
TABLE_8, USER_2_USERNAME,
DATABASE_2_USER_1_WRITE_OWN_ACCESS, USER_2_PRINCIPAL, null),
- Arguments.arguments("private write-all", CONTAINER_1_ID, DATABASE_2_ID, TABLE_8_ID, DATABASE_2,
+ Arguments.arguments("private write-all", DATABASE_2_ID, TABLE_8_ID, DATABASE_2,
TABLE_8, USER_2_USERNAME,
DATABASE_2_USER_1_WRITE_ALL_ACCESS, USER_2_PRINCIPAL, null)
);
@@ -427,12 +426,12 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
@ParameterizedTest
@WithMockUser(username = USER_1_USERNAME, authorities = {"insert-table-data"})
@MethodSource("getAll_succeeds_parameters")
- public void getCount_succeeds(String test, Long containerId, Long databaseId, Long tableId, Database database,
+ public void getCount_succeeds(String test, Long databaseId, Long tableId, Database database,
Table table, String username, DatabaseAccess access, Principal principal,
Instant timestamp) throws UserNotFoundException, TableNotFoundException, QueryStoreException, SortException, TableMalformedException, NotAllowedException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, PaginationException, ContainerNotFoundException {
/* test */
- generic_getCount(containerId, databaseId, tableId, database, table, username, access, principal, timestamp);
+ generic_getCount(databaseId, tableId, database, table, username, access, principal, timestamp);
}
@@ -440,47 +439,47 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- public void generic_import(Long containerId, Long databaseId, Database database, Long tableId, Table table,
+ public void generic_import(Long databaseId, Database database, Long tableId, Table table,
String username, DatabaseAccess access, Principal principal) throws DatabaseNotFoundException, TableNotFoundException, NotAllowedException, UserNotFoundException, TableMalformedException, DatabaseConnectionException, QueryMalformedException, ImageNotSupportedException, ContainerNotFoundException {
final ImportDto request = ImportDto.builder().location("test:csv/csv_01.csv").build();
/* mock */
- when(databaseService.find(containerId, databaseId)).thenReturn(database);
- when(tableService.find(containerId, databaseId, tableId)).thenReturn(table);
+ when(databaseService.find(databaseId)).thenReturn(database);
+ when(tableService.find(databaseId, tableId)).thenReturn(table);
when(accessService.find(databaseId, username)).thenReturn(access);
/* test */
- final ResponseEntity<?> response = dataEndpoint.importCsv(containerId, databaseId, tableId, request, principal);
+ final ResponseEntity<?> response = dataEndpoint.importCsv(databaseId, tableId, request, principal);
assertNotNull(response);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
}
- public void generic_insert(Long containerId, Long databaseId, Long tableId, Database database, Table table,
+ public void generic_insert(Long databaseId, Long tableId, Database database, Table table,
String username, DatabaseAccess access, TableCsvDto data, Principal principal) throws DatabaseNotFoundException, TableNotFoundException, NotAllowedException, UserNotFoundException, TableMalformedException, DatabaseConnectionException, ImageNotSupportedException, ContainerNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId)).thenReturn(database);
- when(tableService.find(containerId, databaseId, tableId)).thenReturn(table);
+ when(databaseService.find(databaseId)).thenReturn(database);
+ when(tableService.find(databaseId, tableId)).thenReturn(table);
when(accessService.find(databaseId, username)).thenReturn(access);
/* test */
- final ResponseEntity<?> response = dataEndpoint.insert(containerId, databaseId, tableId, data, principal);
+ final ResponseEntity<?> response = dataEndpoint.insert(databaseId, tableId, data, principal);
assertNotNull(response);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
}
- public void generic_getAll(Long containerId, Long databaseId, Long tableId, Database database, Table table,
+ public void generic_getAll(Long databaseId, Long tableId, Database database, Table table,
String username, DatabaseAccess access, Principal principal, Instant timestamp,
Long page, Long size, SortType sortDirection, String sortColumn) throws UserNotFoundException, TableMalformedException, NotAllowedException, PaginationException, TableNotFoundException, QueryStoreException, SortException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId)).thenReturn(database);
- when(tableService.find(containerId, databaseId, tableId)).thenReturn(table);
+ when(databaseService.find(databaseId)).thenReturn(database);
+ when(tableService.find(databaseId, tableId)).thenReturn(table);
when(accessService.find(databaseId, username)).thenReturn(access);
- when(queryService.tableFindAll(containerId, databaseId, tableId, timestamp, page, size, principal)).thenReturn(QUERY_1_RESULT_DTO);
+ when(queryService.tableFindAll(databaseId, tableId, timestamp, page, size, principal)).thenReturn(QUERY_1_RESULT_DTO);
/* test */
- final ResponseEntity<QueryResultDto> response = dataEndpoint.getAll(containerId, databaseId, tableId,
+ final ResponseEntity<QueryResultDto> response = dataEndpoint.getAll(databaseId, tableId,
principal, timestamp, page, size, sortDirection, sortColumn);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
@@ -489,17 +488,17 @@ public class TableDataEndpointUnitTest extends BaseUnitTest {
assertEquals(QUERY_1_RESULT_RESULT, response.getBody().getResult());
}
- public void generic_getCount(Long containerId, Long databaseId, Long tableId, Database database, Table table,
+ public void generic_getCount(Long databaseId, Long tableId, Database database, Table table,
String username, DatabaseAccess access, Principal principal, Instant timestamp) throws UserNotFoundException, TableMalformedException, NotAllowedException, PaginationException, TableNotFoundException, QueryStoreException, SortException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId)).thenReturn(database);
- when(tableService.find(containerId, databaseId, tableId)).thenReturn(table);
+ when(databaseService.find(databaseId)).thenReturn(database);
+ when(tableService.find(databaseId, tableId)).thenReturn(table);
when(accessService.find(databaseId, username)).thenReturn(access);
- when(queryService.tableCount(containerId, databaseId, tableId, timestamp, principal)).thenReturn(QUERY_1_RESULT_NUMBER);
+ when(queryService.tableCount(databaseId, tableId, timestamp, principal)).thenReturn(QUERY_1_RESULT_NUMBER);
/* test */
- final ResponseEntity<Long> response = dataEndpoint.getCount(containerId, databaseId, tableId,
+ final ResponseEntity<Long> response = dataEndpoint.getCount(databaseId, tableId,
principal, timestamp);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableHistoryEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableHistoryEndpointUnitTest.java
index 3a32885368f8e94f893786f6743aa227ff5095a6..35349d54b02edb8507d419f0c90eeea21dd7f0df 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableHistoryEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/TableHistoryEndpointUnitTest.java
@@ -32,7 +32,8 @@ import java.security.Principal;
import java.util.List;
import java.util.Optional;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.when;
@Log4j2
@@ -79,7 +80,7 @@ public class TableHistoryEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
+ data_generic(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
}
@Test
@@ -89,7 +90,7 @@ public class TableHistoryEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
+ data_generic(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, null, null, null);
}
@Test
@@ -99,7 +100,7 @@ public class TableHistoryEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_1_USER_1_READ_ACCESS);
+ data_generic(DATABASE_1_ID, DATABASE_1, TABLE_1_ID, TABLE_1, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_1_USER_1_READ_ACCESS);
}
@Test
@@ -109,22 +110,22 @@ public class TableHistoryEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- data_generic(CONTAINER_2_ID, DATABASE_2_ID, DATABASE_2, TABLE_4_ID, TABLE_4, USER_1_USERNAME, USER_1_PRINCIPAL, null);
+ data_generic(DATABASE_2_ID, DATABASE_2, TABLE_4_ID, TABLE_4, USER_1_USERNAME, USER_1_PRINCIPAL, null);
}
/* ################################################################################################### */
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- protected void data_generic(Long containerId, Long databaseId, Database database, Long tableId, Table table,
+ protected void data_generic(Long databaseId, Database database, Long tableId, Table table,
String username, Principal principal, DatabaseAccess access)
throws DatabaseNotFoundException, UserNotFoundException, NotAllowedException, DatabaseConnectionException,
QueryMalformedException, QueryStoreException, TableNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
- when(tableService.find(containerId, databaseId, tableId))
+ when(tableService.find(databaseId, tableId))
.thenReturn(table);
if (access != null) {
when(databaseAccessRepository.findByDatabaseIdAndUsername(databaseId, username))
@@ -135,7 +136,7 @@ public class TableHistoryEndpointUnitTest extends BaseUnitTest {
}
/* test */
- final ResponseEntity<List<TableHistoryDto>> response = tableHistoryEndpoint.getAll(containerId, databaseId, tableId, principal);
+ final ResponseEntity<List<TableHistoryDto>> response = tableHistoryEndpoint.getAll(databaseId, tableId, principal);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
index 9644e2113a9ab7c55bfeeaa5fad59f9f1dea3d6a..80687a7330239d6459f683f68c8a5635c4641977 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
@@ -4,7 +4,6 @@ import at.tuwien.BaseUnitTest;
import at.tuwien.api.database.ViewBriefDto;
import at.tuwien.api.database.ViewCreateDto;
import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.query.ExecuteStatementDto;
import at.tuwien.api.database.query.QueryResultDto;
import at.tuwien.config.IndexConfig;
import at.tuwien.config.ReadyConfig;
@@ -12,7 +11,6 @@ import at.tuwien.entities.database.Database;
import at.tuwien.entities.database.DatabaseAccess;
import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
-import at.tuwien.listener.MessageQueueListener;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
import at.tuwien.repository.sdb.ViewIdxRepository;
import at.tuwien.service.AccessService;
@@ -84,7 +82,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, null, null, null);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, null, null, null);
}
@Test
@@ -93,7 +91,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
}
@Test
@@ -102,7 +100,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3_USER_2_READ_ACCESS);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_3_USER_2_READ_ACCESS);
}
@Test
@@ -111,7 +109,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ findAll_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
}
@Test
@@ -120,7 +118,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- create_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, null, null, null);
+ create_generic(DATABASE_3_ID, DATABASE_3, null, null, null);
});
}
@@ -130,7 +128,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- create_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ create_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
});
}
@@ -140,7 +138,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- create_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ create_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -150,7 +148,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- create_generic(CONTAINER_3_ID, DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ create_generic(DATABASE_3_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, null);
});
}
@@ -160,7 +158,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
+ find_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
}
@Test
@@ -169,7 +167,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -178,7 +176,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -187,7 +185,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -196,7 +194,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- delete_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
+ delete_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
});
}
@@ -206,7 +204,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- delete_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ delete_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -216,7 +214,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- delete_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ delete_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -227,7 +225,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
QueryMalformedException {
/* test */
- delete_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_5_ID, DATABASE_3, USER_3_USERNAME, USER_3_PRINCIPAL, DATABASE_3_USER_1_WRITE_ALL_ACCESS);
+ delete_generic(DATABASE_3_ID, VIEW_5_ID, DATABASE_3, USER_3_USERNAME, USER_3_PRINCIPAL, DATABASE_3_USER_1_WRITE_ALL_ACCESS);
}
@Test
@@ -238,7 +236,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
+ data_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, null, null, null);
}
@Test
@@ -249,7 +247,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -260,7 +258,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -271,7 +269,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_3_ID, DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_3_ID, VIEW_1_ID, DATABASE_3, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
/* ################################################################################################### */
@@ -284,7 +282,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, null, null, null);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, null, null, null);
}
@Test
@@ -293,7 +291,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
}
@Test
@@ -302,7 +300,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_1_USER_2_READ_ACCESS);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_1_USER_2_READ_ACCESS);
}
@Test
@@ -311,7 +309,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException {
/* test */
- findAll_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ findAll_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
}
@Test
@@ -320,7 +318,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- create_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, null, null, null);
+ create_generic(DATABASE_1_ID, DATABASE_1, null, null, null);
});
}
@@ -330,7 +328,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- create_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ create_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
});
}
@@ -340,7 +338,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- create_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ create_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -350,7 +348,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- create_generic(CONTAINER_1_ID, DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
+ create_generic(DATABASE_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, null);
});
}
@@ -360,7 +358,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
+ find_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
}
@Test
@@ -369,7 +367,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -378,7 +376,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -387,7 +385,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
DatabaseNotFoundException, ViewNotFoundException {
/* test */
- find_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ find_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -396,7 +394,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- delete_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
+ delete_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
});
}
@@ -406,7 +404,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- delete_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ delete_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -416,7 +414,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(AccessDeniedException.class, () -> {
- delete_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ delete_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
});
}
@@ -427,7 +425,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
QueryMalformedException {
/* test */
- delete_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_ALL_ACCESS);
+ delete_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_1_USERNAME, USER_1_PRINCIPAL, DATABASE_1_USER_1_WRITE_ALL_ACCESS);
}
@Test
@@ -436,7 +434,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
/* test */
assertThrows(NotAllowedException.class, () -> {
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
+ data_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, null, null, null);
});
}
@@ -448,7 +446,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -459,7 +457,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
@Test
@@ -470,19 +468,19 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
ContainerNotFoundException, PaginationException, ViewMalformedException {
/* test */
- data_generic(CONTAINER_1_ID, DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
+ data_generic(DATABASE_1_ID, VIEW_1_ID, DATABASE_1, USER_2_USERNAME, USER_2_PRINCIPAL, DATABASE_2_USER_1_READ_ACCESS);
}
/* ################################################################################################### */
/* ## GENERIC TEST CASES ## */
/* ################################################################################################### */
- protected void findAll_generic(Long containerId, Long databaseId, Database database, String username,
+ protected void findAll_generic(Long databaseId, Database database, String username,
Principal principal, DatabaseAccess access) throws UserNotFoundException,
NotAllowedException, DatabaseNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access != null) {
log.trace("mock access of database with id {} and username {}", databaseId, username);
@@ -499,7 +497,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
}
/* test */
- final ResponseEntity<List<ViewBriefDto>> response = viewEndpoint.findAll(containerId, databaseId, principal);
+ final ResponseEntity<List<ViewBriefDto>> response = viewEndpoint.findAll(databaseId, principal);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
if (access == null) {
@@ -509,7 +507,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
}
}
- protected void create_generic(Long containerId, Long databaseId, Database database, String username,
+ protected void create_generic(Long databaseId, Database database, String username,
Principal principal, DatabaseAccess access) throws DatabaseNotFoundException,
UserNotFoundException, DatabaseConnectionException, ViewMalformedException, QueryMalformedException,
NotAllowedException {
@@ -520,7 +518,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access != null) {
log.trace("mock access of database with id {} and username {}", databaseId, username);
@@ -531,23 +529,23 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
when(accessService.find(databaseId, username))
.thenThrow(NotAllowedException.class);
}
- when(viewService.create(containerId, databaseId, request, principal))
+ when(viewService.create(databaseId, request, principal))
.thenReturn(VIEW_1);
/* test */
- final ResponseEntity<ViewBriefDto> response = viewEndpoint.create(containerId, databaseId, request, principal);
+ final ResponseEntity<ViewBriefDto> response = viewEndpoint.create(databaseId, request, principal);
assertEquals(HttpStatus.CREATED, response.getStatusCode());
assertNotNull(response.getBody());
assertEquals(VIEW_1_ID, response.getBody().getId());
assertEquals(VIEW_1_NAME, response.getBody().getName());
}
- protected void find_generic(Long containerId, Long databaseId, Long viewId, Database database, String username,
+ protected void find_generic(Long databaseId, Long viewId, Database database, String username,
Principal principal, DatabaseAccess access) throws DatabaseNotFoundException,
UserNotFoundException, NotAllowedException, ViewNotFoundException {
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access != null) {
log.trace("mock access of database with id {} and username {}", databaseId, username);
@@ -562,20 +560,20 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
.thenReturn(VIEW_1);
/* test */
- final ResponseEntity<ViewDto> response = viewEndpoint.find(containerId, databaseId, viewId, principal);
+ final ResponseEntity<ViewDto> response = viewEndpoint.find(databaseId, viewId, principal);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
assertEquals(VIEW_1_ID, response.getBody().getId());
assertEquals(VIEW_1_NAME, response.getBody().getName());
}
- protected void delete_generic(Long containerId, Long databaseId, Long viewId, Database database, String username,
+ protected void delete_generic(Long databaseId, Long viewId, Database database, String username,
Principal principal, DatabaseAccess access) throws DatabaseNotFoundException,
UserNotFoundException, NotAllowedException, ViewNotFoundException, DatabaseConnectionException,
ViewMalformedException, QueryMalformedException {
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access != null) {
log.trace("mock access of database with id {} and username {}", databaseId, username);
@@ -588,14 +586,14 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
}
doNothing()
.when(viewService)
- .delete(containerId, databaseId, viewId, principal);
+ .delete(databaseId, viewId, principal);
/* test */
- final ResponseEntity<?> response = viewEndpoint.delete(containerId, databaseId, viewId, principal);
+ final ResponseEntity<?> response = viewEndpoint.delete(databaseId, viewId, principal);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
}
- protected void data_generic(Long containerId, Long databaseId, Long viewId, Database database, String username,
+ protected void data_generic(Long databaseId, Long viewId, Database database, String username,
Principal principal, DatabaseAccess access) throws DatabaseNotFoundException,
UserNotFoundException, NotAllowedException, ViewNotFoundException, DatabaseConnectionException,
QueryMalformedException, QueryStoreException, TableMalformedException, ColumnParseException,
@@ -604,7 +602,7 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
final Long size = 2L;
/* mock */
- when(databaseService.find(containerId, databaseId))
+ when(databaseService.find(databaseId))
.thenReturn(database);
if (access != null) {
log.trace("mock access of database with id {} and username {}", databaseId, username);
@@ -617,11 +615,11 @@ public class ViewEndpointUnitTest extends BaseUnitTest {
}
when(viewService.findById(databaseId, viewId, principal))
.thenReturn(VIEW_1);
- when(queryService.viewFindAll(containerId, databaseId, VIEW_1, page, size, principal))
+ when(queryService.viewFindAll(databaseId, VIEW_1, page, size, principal))
.thenReturn(QUERY_1_RESULT_DTO);
/* test */
- final ResponseEntity<QueryResultDto> response = viewEndpoint.data(containerId, databaseId, viewId, principal, page, size);
+ final ResponseEntity<QueryResultDto> response = viewEndpoint.data(databaseId, viewId, principal, page, size);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertNotNull(response.getBody());
assertEquals(QUERY_1_RESULT_ID, response.getBody().getId());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/listener/RabbitMqListenerIntegrationTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/listener/RabbitMqListenerIntegrationTest.java
index 5acda1d8b2af83ba809bb9e050b7178514b44ac0..6b14efdff80728757d37417165de43c33d892f51 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/listener/RabbitMqListenerIntegrationTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/listener/RabbitMqListenerIntegrationTest.java
@@ -2,14 +2,19 @@ package at.tuwien.listener;
import at.tuwien.BaseUnitTest;
import at.tuwien.api.amqp.ConsumerDto;
-import at.tuwien.config.*;
+import at.tuwien.config.AmqpConfig;
+import at.tuwien.config.IndexConfig;
+import at.tuwien.config.RabbitMqConfig;
+import at.tuwien.config.ReadyConfig;
import at.tuwien.repository.mdb.*;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import lombok.extern.log4j.Log4j2;
import org.junit.Rule;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.rules.Timeout;
import org.springframework.beans.factory.annotation.Autowired;
@@ -17,10 +22,15 @@ import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.RabbitMQContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
import java.io.IOException;
-import java.util.*;
+import java.util.List;
import java.util.stream.Collectors;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -28,6 +38,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
@Log4j2
@ActiveProfiles(profiles = "junit")
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@SpringBootTest
@ExtendWith(SpringExtension.class)
@@ -63,9 +74,6 @@ public class RabbitMqListenerIntegrationTest extends BaseUnitTest {
@Autowired
private TableRepository tableRepository;
- @Autowired
- private H2Utils h2Utils;
-
@Autowired
private RabbitMqConfig rabbitMqConfig;
@@ -75,20 +83,17 @@ public class RabbitMqListenerIntegrationTest extends BaseUnitTest {
@Rule
public Timeout globalTimeout = Timeout.seconds(300);
- @BeforeAll
- public static void beforeAll() throws InterruptedException {
- afterAll();
- /* create networks */
- DockerConfig.createAllNetworks();
- /* create containers */
- DockerConfig.createContainer(null, CONTAINER_BROKER, 15672, CONTAINER_BROKER_ENV);
- DockerConfig.startContainer(CONTAINER_BROKER);
- }
-
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ @Container
+ private static final RabbitMQContainer rabbitMQContainer = new RabbitMQContainer("rabbitmq:3-management-alpine")
+ .withVhost("/");
+
+ @DynamicPropertySource
+ static void rabbitMQProperties(DynamicPropertyRegistry registry) {
+ registry.add("fda.gateway.endpoint", () -> "http://" + rabbitMQContainer.getHost() + ":" + rabbitMQContainer.getHttpPort());
+ registry.add("spring.rabbitmq.host", rabbitMQContainer::getHost);
+ registry.add("spring.rabbitmq.port", rabbitMQContainer::getAmqpPort);
+ registry.add("spring.rabbitmq.username", rabbitMQContainer::getAdminUsername);
+ registry.add("spring.rabbitmq.password", rabbitMQContainer::getAdminPassword);
}
@BeforeEach
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/repository/ViewIdxRepositoryIntegrationTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/repository/ViewIdxRepositoryIntegrationTest.java
index 1dd83a35bb7bbc2f9d4f27e1b8b641df2d44ac1d..0cd9ef8c6bd326444df4b88e56ee55adc140173c 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/repository/ViewIdxRepositoryIntegrationTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/repository/ViewIdxRepositoryIntegrationTest.java
@@ -3,40 +3,49 @@ package at.tuwien.repository;
import at.tuwien.BaseUnitTest;
import at.tuwien.api.database.ViewCreateDto;
import at.tuwien.api.database.ViewDto;
+import at.tuwien.config.MariaDbConfig;
import at.tuwien.config.ReadyConfig;
import at.tuwien.entities.database.View;
import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
+import at.tuwien.repository.mdb.DatabaseRepository;
+import at.tuwien.repository.mdb.UserRepository;
+import at.tuwien.repository.mdb.ViewRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
-import at.tuwien.repository.mdb.*;
import at.tuwien.service.ViewService;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.extern.log4j.Log4j2;
import org.junit.Rule;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.rules.Timeout;
+import org.opensearch.testcontainers.OpensearchContainer;
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.test.annotation.DirtiesContext;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.utility.DockerImageName;
-import java.io.File;
+import java.sql.SQLException;
import java.util.List;
import java.util.Optional;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@SpringBootTest
@ExtendWith(SpringExtension.class)
@@ -72,31 +81,26 @@ public class ViewIdxRepositoryIntegrationTest extends BaseUnitTest {
@Rule
public Timeout globalTimeout = Timeout.seconds(60);
- static final String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
-
- @BeforeAll
- public static void beforeAll() throws InterruptedException {
- afterAll();
- /* create network */
- DockerConfig.createAllNetworks();
- /* create elastic search */
- DockerConfig.createContainer(null, CONTAINER_ELASTIC, CONTAINER_ELASTIC_ENV);
- DockerConfig.startContainer(CONTAINER_ELASTIC);
- /* create container */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- }
+ @Container
+ @Autowired
+ private MariaDBContainer<?> mariaDBContainer;
+
+ @Container
+ private static final OpensearchContainer opensearchContainer = new OpensearchContainer(DockerImageName.parse("opensearchproject/opensearch:2"));
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ @DynamicPropertySource
+ static void elasticsearchProperties(DynamicPropertyRegistry registry) {
+ registry.add("spring.opensearch.uris", () -> opensearchContainer.getHttpHostAddress().substring(7));
+ registry.add("spring.opensearch.username", opensearchContainer::getUsername);
+ registry.add("spring.opensearch.password", opensearchContainer::getPassword);
}
@BeforeEach
- public void beforeEach() {
+ public void beforeEach() throws SQLException {
DATABASE_1.setTables(List.of(TABLE_1, TABLE_2, TABLE_3, TABLE_7));
DATABASE_1.setViews(List.of(VIEW_1));
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
}
@Test
@@ -109,7 +113,7 @@ public class ViewIdxRepositoryIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
@@ -117,7 +121,7 @@ public class ViewIdxRepositoryIntegrationTest extends BaseUnitTest {
.thenReturn(VIEW_1);
/* test */
- viewService.create(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ viewService.create(DATABASE_1_ID, request, USER_1_PRINCIPAL);
final Optional<ViewDto> response = viewIdxRepository.findById(VIEW_1_ID);
assertTrue(response.isPresent());
final ViewDto view = response.get();
@@ -125,7 +129,6 @@ public class ViewIdxRepositoryIntegrationTest extends BaseUnitTest {
assertEquals(VIEW_1_NAME, view.getName());
assertEquals(VIEW_1_INTERNAL_NAME, view.getInternalName());
assertEquals(VIEW_1_QUERY, view.getQuery());
- assertEquals(VIEW_1_CONTAINER_ID, view.getVdbid());
assertEquals(VIEW_1_DATABASE_ID, view.getVdbid());
assertEquals(VIEW_1_PUBLIC, view.getIsPublic());
}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueryServiceIntegrationTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueryServiceIntegrationTest.java
index 7e8d87f8069fa7f1ce941fc5b2ba03c0671fa75a..29e390be4ec332ca9a56436051c2b031e0b6f2e9 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueryServiceIntegrationTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueryServiceIntegrationTest.java
@@ -12,15 +12,15 @@ import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
import at.tuwien.querystore.Query;
-import at.tuwien.repository.mdb.*;
+import at.tuwien.repository.mdb.DatabaseRepository;
+import at.tuwien.repository.mdb.TableRepository;
+import at.tuwien.repository.mdb.UserRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.SneakyThrows;
import lombok.extern.log4j.Log4j2;
-import org.junit.Rule;
-import org.junit.rules.Timeout;
-import org.junit.jupiter.api.*;
+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.autoconfigure.EnableAutoConfiguration;
@@ -29,8 +29,10 @@ import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
import java.math.BigInteger;
import java.sql.SQLException;
import java.time.Instant;
@@ -46,6 +48,7 @@ import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@EnableAutoConfiguration(exclude = RabbitAutoConfiguration.class)
@SpringBootTest
@@ -82,18 +85,15 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Autowired
private QueryService queryService;
- @Rule
- public Timeout globalTimeout = Timeout.seconds(60);
-
- private final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
-
- private final static String BIND_ZOO = new File("../../dbrepo-metadata-db/test/src/test/resources/zoo").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
+ @Container
+ @Autowired
+ private MariaDBContainer<?> mariaDBContainer;
@BeforeEach
- public void beforeEach() {
- afterEach();
- /* create network */
- DockerConfig.createAllNetworks();
+ public void beforeEach() throws SQLException {
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_2);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
/* metadata database */
DATABASE_1.setTables(List.of(TABLE_1, TABLE_2, TABLE_3, TABLE_7));
DATABASE_1.setViews(List.of(VIEW_2, VIEW_3));
@@ -101,28 +101,19 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
DATABASE_2.setViews(List.of(VIEW_4));
}
- @AfterEach
- public void afterEach() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
- }
-
@Test
public void findAll_succeeds() throws DatabaseNotFoundException, ImageNotSupportedException,
TableMalformedException, TableNotFoundException, DatabaseConnectionException,
- PaginationException, ContainerNotFoundException, QueryMalformedException, UserNotFoundException,
- InterruptedException {
+ PaginationException, QueryMalformedException, UserNotFoundException {
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final QueryResultDto result = queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, Instant.now(),
+ final QueryResultDto result = queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, Instant.now(),
null, null, USER_1_PRINCIPAL);
assertEquals(3, result.getResult().size());
assertEquals(BigInteger.valueOf(1L), result.getResult().get(0).get(COLUMN_1_1_INTERNAL_NAME));
@@ -145,65 +136,58 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void selectAll_succeeds() throws TableNotFoundException, DatabaseConnectionException,
DatabaseNotFoundException, ImageNotSupportedException, TableMalformedException, PaginationException,
- ContainerNotFoundException, QueryMalformedException, UserNotFoundException, InterruptedException {
+ QueryMalformedException, UserNotFoundException {
final Long page = 0L;
final Long size = 10L;
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, Instant.now(), page, size, USER_1_PRINCIPAL);
+ queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, Instant.now(), page, size, USER_1_PRINCIPAL);
}
@Test
- public void selectAll_noTable_fails() throws InterruptedException {
+ public void selectAll_noTable_fails() {
final Long page = 0L;
final Long size = 10L;
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.empty());
/* test */
assertThrows(TableNotFoundException.class, () -> {
- queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, Instant.now(), page, size, USER_1_PRINCIPAL);
+ queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, Instant.now(), page, size, USER_1_PRINCIPAL);
});
}
@Test
- public void insert_columns_fails() throws InterruptedException {
+ public void insert_columns_fails() {
final TableCsvDto request = TableCsvDto.builder()
.data(Map.of("key", "some_value"))
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
assertThrows(TableMalformedException.class, () -> {
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
});
}
@Test
- public void insert_date_succeeds() throws InterruptedException, UserNotFoundException, TableNotFoundException,
- TableMalformedException, DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException,
- ContainerNotFoundException, SQLException {
+ public void insert_date_succeeds() throws UserNotFoundException, TableNotFoundException, TableMalformedException,
+ DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException, SQLException {
final TableCsvDto request = TableCsvDto.builder()
.data(new HashMap<>() {{
put("id", 4L);
@@ -214,16 +198,14 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
}}).build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
- final List<Map<String, String>> response = MariaDbConfig.selectQuery(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, "SELECT `id`, `date`, `location` FROM `weather_aus` WHERE `id` = 4", "id", "date", "location");
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ final List<Map<String, String>> response = MariaDbConfig.selectQuery(DATABASE_1, "SELECT `id`, `date`, `location` FROM `weather_aus` WHERE `id` = 4", "id", "date", "location");
final Map<String, String> row1 = response.get(0);
assertEquals("4", row1.get("id"));
assertEquals("2022-10-30", row1.get("date"));
@@ -232,8 +214,7 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void insert_timestamp_succeeds() throws UserNotFoundException, TableNotFoundException, TableMalformedException,
- DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException,
- ContainerNotFoundException, InterruptedException {
+ DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException {
final TableCsvDto request = TableCsvDto.builder()
.data(new HashMap<>() {{
put("timestamp", "2023-02-10 12:15:20");
@@ -241,21 +222,18 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
}}).build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_7_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_7_ID))
.thenReturn(Optional.of(TABLE_7));
/* test */
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_7_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_7_ID, request, USER_1_PRINCIPAL);
}
@Test
public void insert_timestampMillis_succeeds() throws UserNotFoundException, TableNotFoundException, TableMalformedException,
- DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException,
- ContainerNotFoundException, InterruptedException {
+ DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException {
final TableCsvDto request = TableCsvDto.builder()
.data(new HashMap<>() {{
put("timestamp", "2023-02-10 12:15:20.613405");
@@ -263,21 +241,18 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
}}).build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_7_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_7_ID))
.thenReturn(Optional.of(TABLE_7));
/* test */
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_7_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_7_ID, request, USER_1_PRINCIPAL);
}
@Test
public void insert_withConstraints_succeeds() throws UserNotFoundException, TableNotFoundException,
- TableMalformedException, DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException,
- ContainerNotFoundException, InterruptedException {
+ TableMalformedException, DatabaseConnectionException, DatabaseNotFoundException, ImageNotSupportedException {
final TableCsvDto request = TableCsvDto.builder()
.data(Map.of("id", 4L,
"date", "2008-12-04",
@@ -287,19 +262,17 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
}
@Test
- public void insert_violatingForeignKey_fails() throws InterruptedException {
+ public void insert_violatingForeignKey_fails() {
final TableCsvDto request = TableCsvDto.builder()
.data(Map.of("id", 4L,
"date", "2008-12-04",
@@ -309,21 +282,19 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
assertThrows(TableMalformedException.class, () -> {
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
});
}
@Test
- public void insert_violatingUnique_fails() throws InterruptedException {
+ public void insert_violatingUnique_fails() {
final TableCsvDto request = TableCsvDto.builder()
.data(Map.of("id", 4L,
"date", "2008-12-03", // entry with date already exists
@@ -333,21 +304,19 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
assertThrows(TableMalformedException.class, () -> {
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
});
}
@Test
- public void insert_violatingCheck_fails() throws InterruptedException {
+ public void insert_violatingCheck_fails() {
final TableCsvDto request = TableCsvDto.builder()
.data(Map.of("id", 4L,
"date", "2008-12-04",
@@ -357,73 +326,66 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
assertThrows(TableMalformedException.class, () -> {
- queryService.insert(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
+ queryService.insert(DATABASE_1_ID, TABLE_1_ID, request, USER_1_PRINCIPAL);
});
}
@Test
public void findAll_timestampMissing_succeeds() throws TableNotFoundException, DatabaseConnectionException,
TableMalformedException, DatabaseNotFoundException, ImageNotSupportedException, PaginationException,
- ContainerNotFoundException, QueryMalformedException, UserNotFoundException, InterruptedException {
+ QueryMalformedException, UserNotFoundException {
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, null, null, null, USER_1_PRINCIPAL);
+ queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, null, null, null, USER_1_PRINCIPAL);
}
@Test
public void findAll_timestampBeforeCreation_succeeds() throws TableNotFoundException, DatabaseConnectionException,
TableMalformedException, DatabaseNotFoundException, ImageNotSupportedException, PaginationException,
- ContainerNotFoundException, QueryMalformedException, UserNotFoundException, InterruptedException {
+ QueryMalformedException, UserNotFoundException {
final Instant timestamp = DATABASE_1_CREATED.minus(1, ChronoUnit.SECONDS);
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, timestamp, null, null, USER_1_PRINCIPAL);
- queryService.tableFindAll(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, timestamp, null, null, USER_1_PRINCIPAL);
+ queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, timestamp, null, null, USER_1_PRINCIPAL);
+ queryService.tableFindAll(DATABASE_1_ID, TABLE_1_ID, timestamp, null, null, USER_1_PRINCIPAL);
}
@Test
public void execute_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT n.`firstname`, n.`lastname`, z.`animal_name`, z.`legs` FROM `likes` l JOIN `names` n ON l.`name_id` = n.`id` JOIN `mock_view` z ON z.`id` = l.`zoo_id`")
.build();
/* mock */
- DockerConfig.createContainer(BIND_ZOO, CONTAINER_2, CONTAINER_2_ENV);
- DockerConfig.startContainer(CONTAINER_2);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_2_ID, DATABASE_2_ID))
+ Thread.sleep(2000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_2_ID))
.thenReturn(Optional.of(DATABASE_2));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_2_ID, DATABASE_2_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_2_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(4L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -448,22 +410,21 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void execute_withoutNullField_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT `location`, `lng` FROM `weather_location` WHERE `lat` IS NULL")
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ Thread.sleep(1000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(1L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -475,22 +436,21 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void execute_withoutNullField2_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT `location` FROM `weather_location` WHERE `lat` IS NULL")
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ Thread.sleep(1000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(1L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -502,22 +462,21 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void execute_withNullField_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT `lat`, `lng` FROM `weather_location` WHERE `lat` IS NULL")
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ Thread.sleep(1000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(1L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -525,22 +484,21 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void execute_aliases_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT aus.location as a, loc.location from weather_aus aus, weather_location loc")
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ Thread.sleep(1000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(9L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -567,22 +525,21 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void execute_aliasesWithDatabaseName_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException,
UserNotFoundException, QueryStoreException, ColumnParseException, InterruptedException {
final ExecuteStatementDto request = ExecuteStatementDto.builder()
.statement("SELECT aus.location as a, loc.location from weather.weather_aus aus, weather.weather_location loc")
.build();
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ Thread.sleep(1000); // wait for database creation
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL,
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL,
0L, 100L, null, null);
assertEquals(9L, response.getResultNumber());
assertNotNull(response.getResult());
@@ -609,9 +566,8 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
@Test
public void count_emptySet_succeeds() throws DatabaseConnectionException, TableMalformedException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, QueryMalformedException,
- UserNotFoundException, QueryStoreException, InterruptedException, QueryNotFoundException,
- FileStorageException, SQLException {
+ DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException, UserNotFoundException,
+ QueryStoreException, QueryNotFoundException, FileStorageException, SQLException {
final Query query = Query.builder()
.id(QUERY_1_ID)
.query("SELECT `location`, `lat`, `lng` FROM `weather_location` WHERE `location` = \"Vienna\"")
@@ -626,16 +582,14 @@ public class QueryServiceIntegrationTest extends BaseUnitTest {
/* mock */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, query, USER_1_USERNAME);
+ MariaDbConfig.insertQueryStore(DATABASE_1, query, USER_1_USERNAME);
/* test */
- final ExportResource response = queryService.findOne(CONTAINER_1_ID, DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
+ final ExportResource response = queryService.findOne(DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
assertNotNull(response.getFilename());
assertNotNull(response.getResource());
}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
index 7bc34bce9e0b2a967ae24f5cf082aabfd256e2c1..4880281b2d3c5fea03e9e8c1b54f11087a5712e3 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
@@ -14,15 +14,24 @@ import at.tuwien.repository.sdb.ViewIdxRepository;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.*;
import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+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.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.containers.RabbitMQContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
import java.io.IOException;
+import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Optional;
@@ -36,6 +45,7 @@ import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@SpringBootTest
@ExtendWith(SpringExtension.class)
public class QueueServiceIntegrationTest extends BaseUnitTest {
@@ -79,22 +89,26 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
@Autowired
private MessageQueueService messageQueueService;
- private final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
+ @Container
+ private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
- @BeforeAll
- public static void beforeAll() throws InterruptedException {
- afterAll();
- DockerConfig.createAllNetworks();
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_3, CONTAINER_3_ENV);
- DockerConfig.startContainer(CONTAINER_3);
- DockerConfig.createContainer(null, CONTAINER_BROKER, CONTAINER_BROKER_ENV);
- DockerConfig.startContainer(CONTAINER_BROKER);
+ @Container
+ private static final RabbitMQContainer rabbitMQContainer = new RabbitMQContainer("rabbitmq:3-management-alpine")
+ .withVhost("/");
+
+ @DynamicPropertySource
+ static void rabbitMQProperties(DynamicPropertyRegistry registry) {
+ registry.add("fda.gateway.endpoint", () -> "http://" + rabbitMQContainer.getHost() + ":" + rabbitMQContainer.getHttpPort());
+ registry.add("spring.rabbitmq.host", rabbitMQContainer::getHost);
+ registry.add("spring.rabbitmq.port", rabbitMQContainer::getAmqpPort);
+ registry.add("spring.rabbitmq.username", rabbitMQContainer::getAdminUsername);
+ registry.add("spring.rabbitmq.password", rabbitMQContainer::getAdminPassword);
}
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ @BeforeAll
+ public static void beforeAll() throws SQLException {
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
}
@BeforeEach
@@ -112,7 +126,7 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
public void createConsumer_succeeds() throws AmqpException {
/* test */
- messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID);
+ messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, DATABASE_3_ID, TABLE_8_ID);
}
@Test
@@ -122,7 +136,7 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
channel.close();
/* test */
- messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID);
+ messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, DATABASE_3_ID, TABLE_8_ID);
}
@Test
@@ -140,14 +154,14 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
}}).build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_3_ID, DATABASE_3_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_3_ID))
.thenReturn(Optional.of(DATABASE_3));
- when(tableRepository.find(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID))
+ when(tableRepository.find(DATABASE_3_ID, TABLE_8_ID))
.thenReturn(Optional.of(TABLE_8));
doThrow(IOException.class)
.when(rabbitMqConsumer)
.handleDelivery(anyString(), any(Envelope.class), any(AMQP.BasicProperties.class), any());
- messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID);
+ messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, DATABASE_3_ID, TABLE_8_ID);
/* test */
channel.basicPublish(DATABASE_3_EXCHANGE, TABLE_8_ROUTING_KEY, basicProperties, objectMapper.writeValueAsBytes(payload));
@@ -162,14 +176,14 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_3_ID, DATABASE_3_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_3_ID))
.thenReturn(Optional.of(DATABASE_3));
- when(tableRepository.find(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID))
+ when(tableRepository.find(DATABASE_3_ID, TABLE_8_ID))
.thenReturn(Optional.of(TABLE_8));
doThrow(IOException.class)
.when(rabbitMqConsumer)
.handleDelivery(anyString(), any(Envelope.class), any(AMQP.BasicProperties.class), any());
- messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID);
+ messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, DATABASE_3_ID, TABLE_8_ID);
/* test */
channel.basicPublish(DATABASE_3_EXCHANGE, TABLE_8_ROUTING_KEY, basicProperties, objectMapper.writeValueAsBytes(TABLE_8_CSV_DTO));
@@ -183,14 +197,14 @@ public class QueueServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_3_ID, DATABASE_3_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_3_ID))
.thenReturn(Optional.of(DATABASE_3));
- when(tableRepository.find(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID))
+ when(tableRepository.find(DATABASE_3_ID, TABLE_8_ID))
.thenReturn(Optional.of(TABLE_8));
doThrow(IOException.class)
.when(rabbitMqConsumer)
.handleDelivery(anyString(), any(Envelope.class), any(AMQP.BasicProperties.class), any());
- messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID);
+ messageQueueService.createConsumer(TABLE_8_QUEUE_NAME, DATABASE_3_ID, TABLE_8_ID);
/* test */
channel.basicPublish(DATABASE_3_EXCHANGE, TABLE_8_ROUTING_KEY, basicProperties, objectMapper.writeValueAsBytes(TABLE_8_CSV_DTO));
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationModifyTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationModifyTest.java
index 559633c43bdeab1f176261266dfc80048779a623..a6be292e502ef44c1d8247b4c6e5282f699aac8f 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationModifyTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationModifyTest.java
@@ -10,13 +10,15 @@ import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
import at.tuwien.querystore.Query;
-import at.tuwien.repository.mdb.*;
+import at.tuwien.repository.mdb.DatabaseRepository;
+import at.tuwien.repository.mdb.TableRepository;
+import at.tuwien.repository.mdb.UserRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.extern.log4j.Log4j2;
import org.apache.http.auth.BasicUserPrincipal;
-import org.junit.jupiter.api.*;
+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.autoconfigure.EnableAutoConfiguration;
@@ -25,13 +27,15 @@ import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
import java.security.Principal;
import java.sql.SQLException;
-import java.util.List;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -40,6 +44,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@EnableAutoConfiguration(exclude = RabbitAutoConfiguration.class)
@ExtendWith(SpringExtension.class)
@@ -76,41 +81,21 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
@Autowired
private StoreService storeService;
- final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
-
@Autowired
private QueryService queryService;
- @BeforeAll
- public static void beforeAll() {
- afterAll();
- DockerConfig.createAllNetworks();
- }
+ @Container
+ @Autowired
+ private MariaDBContainer<?> mariaDBContainer;
@BeforeEach
- public void beforeEach() throws InterruptedException {
- afterEach();
- /* create networks */
- DockerConfig.createAllNetworks();
- /* create containers */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
+ public void beforeEach() throws InterruptedException, SQLException {
/* metadata database */
userRepository.save(USER_5);
DATABASE_1.setTables(List.of(TABLE_1, TABLE_2, TABLE_3, TABLE_7));
DATABASE_1.setViews(List.of(VIEW_3));
- }
-
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
- }
-
- @AfterEach
- public void afterEach() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
}
@Test
@@ -124,13 +109,13 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, QUERY_1, USER_1_USERNAME);
+ MariaDbConfig.insertQueryStore(DATABASE_1, QUERY_1, USER_1_USERNAME);
/* test */
- final Query response = storeService.insert(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
- log.debug("found queries in query store: {}", MariaDbConfig.selectQuery(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME,
+ final Query response = storeService.insert(DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ log.debug("found queries in query store: {}", MariaDbConfig.selectQuery(DATABASE_1,
"SELECT `query_normalized`, `query_hash`, `result_hash` FROM `qs_queries`", "query_normalized", "query_hash", "result_hash"));
assertEquals(QUERY_1_ID, response.getId()) /* no new query inserted */;
}
@@ -149,12 +134,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, mock, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ queryService.execute(DATABASE_1_ID, mock, USER_1_PRINCIPAL, 0L, 10L, null, null);
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
assertEquals(2L, response.getId()) /* new query inserted */;
}
@@ -169,12 +154,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
assertEquals(1L, response.getId()) /* no new query inserted */;
}
@@ -189,11 +174,11 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
assertEquals(1L, response.getId()) /* new query inserted */;
}
@@ -208,12 +193,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
/* test */
- final QueryResultDto response = queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ final QueryResultDto response = queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
assertEquals(1L, response.getId()) /* no new query inserted */;
}
@@ -228,13 +213,13 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
- MariaDbConfig.execute(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, "INSERT INTO weather_aus (id, `date`, location, mintemp, rainfall) VALUES (4, '2008-12-04', 'Albury', 12.9, 0.2)");
+ queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ MariaDbConfig.execute(DATABASE_1, "INSERT INTO weather_aus (id, `date`, location, mintemp, rainfall) VALUES (4, '2008-12-04', 'Albury', 12.9, 0.2)");
/* test */
- storeService.insert(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ storeService.insert(DATABASE_1_ID, request, USER_1_PRINCIPAL);
}
@Test
@@ -246,12 +231,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(QueryMalformedException.class, () -> {
- queryService.execute(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
+ queryService.execute(DATABASE_1_ID, request, USER_1_PRINCIPAL, 0L, 10L, null, null);
});
}
@@ -267,11 +252,11 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- storeService.insert(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ storeService.insert(DATABASE_1_ID, request, USER_1_PRINCIPAL);
}
@Test
@@ -285,11 +270,11 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_5_USERNAME))
.thenReturn(Optional.of(USER_5));
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- storeService.insert(CONTAINER_1_ID, DATABASE_1_ID, request, null);
+ storeService.insert(DATABASE_1_ID, request, null);
}
@Test
@@ -301,12 +286,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
/* mock */
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.empty());
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(UserNotFoundException.class, () -> {
- storeService.insert(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ storeService.insert(DATABASE_1_ID, request, USER_1_PRINCIPAL);
});
}
@@ -315,24 +300,24 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException, SQLException {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, QUERY_1, USER_1_USERNAME);
+ MariaDbConfig.insertQueryStore(DATABASE_1, QUERY_1, USER_1_USERNAME);
/* test */
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
+ storeService.findOne(DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
}
@Test
public void findOne_notFound_succeeds() {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(QueryNotFoundException.class, () -> {
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, 9999L, USER_1_PRINCIPAL);
+ storeService.findOne(DATABASE_1_ID, 9999L, USER_1_PRINCIPAL);
});
}
@@ -341,12 +326,12 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
final Principal principal = new BasicUserPrincipal(USER_1_USERNAME);
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(QueryNotFoundException.class, () -> {
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, 9999L, principal);
+ storeService.findOne(DATABASE_1_ID, 9999L, principal);
});
}
@@ -376,14 +361,14 @@ public class StoreServiceIntegrationModifyTest extends BaseUnitTest {
.build();
/* mock */
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, queryOk, USER_1_USERNAME);
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, queryDelete, USER_1_USERNAME);
+ MariaDbConfig.insertQueryStore(DATABASE_1, queryOk, USER_1_USERNAME);
+ MariaDbConfig.insertQueryStore(DATABASE_1, queryDelete, USER_1_USERNAME);
when(databaseRepository.findAll())
.thenReturn(List.of(DATABASE_1));
/* test */
storeService.deleteStaleQueries();
- final List<Map<String, Object>> response = MariaDbConfig.listQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME);
+ final List<Map<String, Object>> response = MariaDbConfig.listQueryStore(DATABASE_1);
assertEquals(1, response.size());
}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationReadTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationReadTest.java
index f41d511770598114e12016f50a645396106f7680..e9f67eb1851fe4481107879bcc2f65954add91d6 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationReadTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/StoreServiceIntegrationReadTest.java
@@ -3,6 +3,7 @@ package at.tuwien.service;
import at.tuwien.BaseUnitTest;
import at.tuwien.config.IndexConfig;
import at.tuwien.config.MariaDbConfig;
+import at.tuwien.config.MariaDbContainerConfig;
import at.tuwien.config.ReadyConfig;
import at.tuwien.exception.*;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
@@ -12,10 +13,11 @@ import at.tuwien.repository.mdb.TableRepository;
import at.tuwien.repository.mdb.UserRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.extern.log4j.Log4j2;
import org.apache.http.auth.BasicUserPrincipal;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeAll;
+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.autoconfigure.EnableAutoConfiguration;
@@ -23,8 +25,10 @@ import org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
import java.security.Principal;
import java.sql.SQLException;
import java.util.List;
@@ -35,6 +39,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@ExtendWith(SpringExtension.class)
@EnableAutoConfiguration(exclude= RabbitAutoConfiguration.class)
@SpringBootTest
@@ -67,18 +72,15 @@ public class StoreServiceIntegrationReadTest extends BaseUnitTest {
@Autowired
private StoreService storeService;
- final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
+ @Container
+ private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
@BeforeAll
- public static void beforeAll() throws InterruptedException, SQLException {
- afterAll();
- /* create networks */
- DockerConfig.createAllNetworks();
- /* create user container */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
+ public static void beforeAll() throws SQLException {
/* insert query */
- MariaDbConfig.insertQueryStore(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME, QUERY_1, USER_1_USERNAME);
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
+ MariaDbConfig.insertQueryStore(DATABASE_1, QUERY_1, USER_1_USERNAME);
}
@BeforeEach
@@ -89,22 +91,16 @@ public class StoreServiceIntegrationReadTest extends BaseUnitTest {
DATABASE_1.setViews(List.of(VIEW_3));
}
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
- }
-
@Test
public void findAll_succeeds() throws UserNotFoundException, QueryStoreException, DatabaseConnectionException,
DatabaseNotFoundException, ImageNotSupportedException, TableMalformedException, ContainerNotFoundException {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- final List<Query> queries = storeService.findAll(CONTAINER_1_ID, DATABASE_1_ID, null, USER_1_PRINCIPAL);
+ final List<Query> queries = storeService.findAll(DATABASE_1_ID, null, USER_1_PRINCIPAL);
assertEquals(1, queries.size());
}
@@ -113,11 +109,11 @@ public class StoreServiceIntegrationReadTest extends BaseUnitTest {
DatabaseNotFoundException, ImageNotSupportedException, TableMalformedException, ContainerNotFoundException {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- final List<Query> queries = storeService.findAll(CONTAINER_1_ID, DATABASE_1_ID, true, USER_1_PRINCIPAL);
+ final List<Query> queries = storeService.findAll(DATABASE_1_ID, true, USER_1_PRINCIPAL);
assertEquals(0, queries.size());
}
@@ -126,23 +122,23 @@ public class StoreServiceIntegrationReadTest extends BaseUnitTest {
DatabaseConnectionException, QueryNotFoundException, DatabaseNotFoundException, ImageNotSupportedException {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
+ storeService.findOne(DATABASE_1_ID, QUERY_1_ID, USER_1_PRINCIPAL);
}
@Test
public void findOne_notFound_succeeds() {
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(QueryNotFoundException.class, () -> {
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, 9999L, USER_1_PRINCIPAL);
+ storeService.findOne(DATABASE_1_ID, 9999L, USER_1_PRINCIPAL);
});
}
@@ -151,12 +147,12 @@ public class StoreServiceIntegrationReadTest extends BaseUnitTest {
final Principal principal = new BasicUserPrincipal(USER_1_USERNAME);
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
/* test */
assertThrows(QueryNotFoundException.class, () -> {
- storeService.findOne(CONTAINER_1_ID, DATABASE_1_ID, QUERY_2_ID, principal);
+ storeService.findOne(DATABASE_1_ID, QUERY_2_ID, principal);
});
}
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationReadTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationReadTest.java
index f7b8b21bffaf654347245c223cec91437f1fe6f6..cfdccd21a929a27ea9262f783ce77b34e1b54101 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationReadTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationReadTest.java
@@ -2,8 +2,9 @@ package at.tuwien.service;
import at.tuwien.BaseUnitTest;
import at.tuwien.api.database.table.TableHistoryDto;
-import at.tuwien.config.H2Utils;
import at.tuwien.config.IndexConfig;
+import at.tuwien.config.MariaDbConfig;
+import at.tuwien.config.MariaDbContainerConfig;
import at.tuwien.config.ReadyConfig;
import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
@@ -11,9 +12,10 @@ import at.tuwien.listener.impl.RabbitMqListenerImpl;
import at.tuwien.repository.mdb.*;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeAll;
+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.autoconfigure.EnableAutoConfiguration;
@@ -24,8 +26,11 @@ import org.springframework.security.test.context.support.WithAnonymousUser;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
+import java.sql.SQLException;
import java.util.List;
import java.util.Optional;
@@ -34,6 +39,7 @@ import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@EnableAutoConfiguration(exclude= RabbitAutoConfiguration.class)
@SpringBootTest
@@ -79,25 +85,13 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
@Autowired
private TableService tableService;
- @Autowired
- private H2Utils h2Utils;
-
- final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
+ @Container
+ private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
@BeforeAll
- public static void beforeAll() throws InterruptedException {
- afterAll();
- /* create networks */
- DockerConfig.createAllNetworks();
- /* user container */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- }
-
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ public static void beforeAll() throws SQLException {
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
}
@BeforeEach
@@ -120,11 +114,11 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
QueryStoreException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final List<TableHistoryDto> response = tableService.findHistory(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, null);
+ final List<TableHistoryDto> response = tableService.findHistory(DATABASE_1_ID, TABLE_1_ID, null);
assertEquals(1, response.size());
final TableHistoryDto history = response.get(0);
assertEquals("INSERT", history.getEvent());
@@ -136,11 +130,11 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
QueryStoreException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final List<TableHistoryDto> response = tableService.findHistory(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, null);
+ final List<TableHistoryDto> response = tableService.findHistory(DATABASE_1_ID, TABLE_1_ID, null);
assertEquals(1, response.size());
final TableHistoryDto history = response.get(0);
assertEquals("INSERT", history.getEvent());
@@ -152,11 +146,11 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
QueryStoreException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final List<TableHistoryDto> response = tableService.findHistory(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, USER_1_PRINCIPAL);
+ final List<TableHistoryDto> response = tableService.findHistory(DATABASE_1_ID, TABLE_1_ID, USER_1_PRINCIPAL);
assertEquals(1, response.size());
final TableHistoryDto history = response.get(0);
assertEquals("INSERT", history.getEvent());
@@ -168,11 +162,11 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
QueryStoreException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final List<TableHistoryDto> response = tableService.findHistory(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, USER_2_PRINCIPAL);
+ final List<TableHistoryDto> response = tableService.findHistory(DATABASE_1_ID, TABLE_1_ID, USER_2_PRINCIPAL);
assertEquals(1, response.size());
final TableHistoryDto history = response.get(0);
assertEquals("INSERT", history.getEvent());
@@ -184,11 +178,11 @@ public class TableServiceIntegrationReadTest extends BaseUnitTest {
QueryStoreException, DatabaseConnectionException, QueryMalformedException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID))
+ when(tableRepository.find(DATABASE_1_ID, TABLE_1_ID))
.thenReturn(Optional.of(TABLE_1));
/* test */
- final List<TableHistoryDto> response = tableService.findHistory(CONTAINER_1_ID, DATABASE_1_ID, TABLE_1_ID, USER_3_PRINCIPAL);
+ final List<TableHistoryDto> response = tableService.findHistory(DATABASE_1_ID, TABLE_1_ID, USER_3_PRINCIPAL);
assertEquals(1, response.size());
final TableHistoryDto history = response.get(0);
assertEquals("INSERT", history.getEvent());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
index 5c91cb6b6bc8258a88a414f419c1e9262f169345..1c05a0c42809b7708f6b0033cde4cf4e7bd7c4f8 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
@@ -4,14 +4,15 @@ import at.tuwien.BaseUnitTest;
import at.tuwien.config.IndexConfig;
import at.tuwien.config.ReadyConfig;
import at.tuwien.entities.database.table.columns.TableColumn;
-import at.tuwien.exception.*;
+import at.tuwien.exception.DatabaseNotFoundException;
+import at.tuwien.exception.TableNotFoundException;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
-import at.tuwien.repository.mdb.*;
+import at.tuwien.repository.mdb.TableRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
import com.rabbitmq.client.Channel;
import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -24,7 +25,7 @@ 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.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
@@ -63,11 +64,11 @@ public class TableServiceUnitTest extends BaseUnitTest {
public void findAll_succeeds() throws TableNotFoundException, DatabaseNotFoundException {
/* mock */
- when(tableRepository.find(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID))
+ when(tableRepository.find(DATABASE_3_ID, TABLE_8_ID))
.thenReturn(Optional.of(TABLE_8));
/* test */
- final List<TableColumn> response = tableService.find(CONTAINER_3_ID, DATABASE_3_ID, TABLE_8_ID)
+ final List<TableColumn> response = tableService.find(DATABASE_3_ID, TABLE_8_ID)
.getColumns();
assertEquals(2, response.size());
assertEquals("id", response.get(0).getInternalName());
diff --git a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
index 10d216bf3bfc34f1c0b3b50bc95ea85126edbecc..e4bfed8e2993a75470a008924448077963ea8d7c 100644
--- a/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
+++ b/dbrepo-query-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
@@ -5,17 +5,18 @@ import at.tuwien.api.database.ViewCreateDto;
import at.tuwien.api.database.ViewDto;
import at.tuwien.config.IndexConfig;
import at.tuwien.config.MariaDbConfig;
+import at.tuwien.config.MariaDbContainerConfig;
import at.tuwien.config.ReadyConfig;
import at.tuwien.entities.database.View;
import at.tuwien.exception.*;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.listener.impl.RabbitMqListenerImpl;
+import at.tuwien.repository.mdb.DatabaseRepository;
+import at.tuwien.repository.mdb.UserRepository;
+import at.tuwien.repository.mdb.ViewRepository;
import at.tuwien.repository.sdb.ViewIdxRepository;
-import at.tuwien.repository.mdb.*;
import com.rabbitmq.client.Channel;
-import at.tuwien.config.DockerConfig;
import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -27,8 +28,10 @@ import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
-import java.io.File;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
@@ -41,6 +44,7 @@ import static org.mockito.Mockito.when;
@Log4j2
+@Testcontainers
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
@EnableAutoConfiguration(exclude= RabbitAutoConfiguration.class)
@SpringBootTest
@@ -79,22 +83,13 @@ public class ViewServiceIntegrationTest extends BaseUnitTest {
@Autowired
private ViewService viewService;
- final static String BIND_WEATHER = new File("../../dbrepo-metadata-db/test/src/test/resources/weather").toPath().toAbsolutePath() + ":/docker-entrypoint-initdb.d";
+ @Container
+ private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
@BeforeAll
- public static void beforeAll() throws InterruptedException {
- afterAll();
- /* create network */
- DockerConfig.createAllNetworks();
- /* create container */
- DockerConfig.createContainer(BIND_WEATHER, CONTAINER_1, CONTAINER_1_ENV);
- DockerConfig.startContainer(CONTAINER_1);
- }
-
- @AfterAll
- public static void afterAll() {
- DockerConfig.removeAllContainers();
- DockerConfig.removeAllNetworks();
+ public static void beforeAll() throws SQLException {
+ MariaDbConfig.dropAllDatabases(CONTAINER_1);
+ MariaDbConfig.createInitDatabase(CONTAINER_1, DATABASE_1);
}
@BeforeEach
@@ -113,7 +108,7 @@ public class ViewServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
@@ -123,12 +118,12 @@ public class ViewServiceIntegrationTest extends BaseUnitTest {
.thenReturn(VIEW_3_DTO);
/* test */
- final View response = viewService.create(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ final View response = viewService.create(DATABASE_1_ID, request, USER_1_PRINCIPAL);
assertEquals(VIEW_3_ID, response.getId());
assertEquals(VIEW_3_NAME, response.getName());
assertEquals(VIEW_3_INTERNAL_NAME, response.getInternalName());
assertEquals(VIEW_3_QUERY, response.getQuery());
- final List<Map<String, String>> resultSet = MariaDbConfig.selectQuery(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME,
+ final List<Map<String, String>> resultSet = MariaDbConfig.selectQuery(DATABASE_1,
"SELECT j.* FROM `debug` j", "mintemp", "rainfall", "date", "location");
assertEquals("13.4", resultSet.get(0).get("mintemp"));
assertEquals("0.6", resultSet.get(0).get("rainfall"));
@@ -155,7 +150,7 @@ public class ViewServiceIntegrationTest extends BaseUnitTest {
.build();
/* mock */
- when(databaseRepository.findByContainerIdAndDatabaseId(CONTAINER_1_ID, DATABASE_1_ID))
+ when(databaseRepository.findByDatabaseId(DATABASE_1_ID))
.thenReturn(Optional.of(DATABASE_1));
when(userRepository.findByUsername(USER_1_USERNAME))
.thenReturn(Optional.of(USER_1));
@@ -165,12 +160,12 @@ public class ViewServiceIntegrationTest extends BaseUnitTest {
.thenReturn(VIEW_1_DTO);
/* test */
- final View response = viewService.create(CONTAINER_1_ID, DATABASE_1_ID, request, USER_1_PRINCIPAL);
+ final View response = viewService.create(DATABASE_1_ID, request, USER_1_PRINCIPAL);
assertEquals(VIEW_1_ID, response.getId());
assertEquals(VIEW_1_NAME, response.getName());
assertEquals(VIEW_1_INTERNAL_NAME, response.getInternalName());
assertEquals(VIEW_1_QUERY, response.getQuery());
- final List<Map<String, String>> resultSet = MariaDbConfig.selectQuery(CONTAINER_1_INTERNALNAME, DATABASE_1_INTERNALNAME,
+ final List<Map<String, String>> resultSet = MariaDbConfig.selectQuery(DATABASE_1,
"SELECT l.`location`, l.`lat`, l.`lng` FROM `weather_location` l ORDER BY l.`location` ASC", "location", "lat", "lng");
assertEquals(3, resultSet.size());
final Map<String, String> row0 = resultSet.get(0);
diff --git a/dbrepo-query-service/rest-service/src/test/resources/application.properties b/dbrepo-query-service/rest-service/src/test/resources/application.properties
index c030a10c3744afa02378cbbbccfdd5bbf43bbb59..7f4fe5983422b7e55c5e98e9f922f2e97ddcd790 100644
--- a/dbrepo-query-service/rest-service/src/test/resources/application.properties
+++ b/dbrepo-query-service/rest-service/src/test/resources/application.properties
@@ -9,22 +9,19 @@ spring.cloud.config.discovery.enabled=false
spring.cloud.config.enabled=false
# internal datasource
-# spring 6 fix https://github.com/h2database/h2database/issues/3363
-spring.datasource.url=jdbc:h2:mem:testdb;NON_KEYWORDS=VALUE,KEY;DB_CLOSE_ON_EXIT=FALSE;INIT=CREATE SCHEMA IF NOT EXISTS FDA
-spring.datasource.driverClassName=org.h2.Driver
-spring.datasource.username=sa
-spring.datasource.password=password
-spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
-spring.jpa.hibernate.ddl-auto=create-drop
-spring.jpa.show-sql=false
+spring.datasource.driver-class-name=org.hsqldb.jdbc.JDBCDriver
+spring.datasource.url=jdbc:hsqldb:mem:testdb;db_close_delay=-1;sql.syntax_mys=true
+spring.jpa.database-platform=org.hibernate.dialect.HSQLDialect
+spring.datasource.username=root
+spring.datasource.password=dbrepo
+spring.sql.init.mode=always
+spring.sql.init.schema-locations=classpath*:init/schema.sql
+spring.jpa.hibernate.ddl-auto=create
# additional logging
logging.level.root=error
logging.level.at.tuwien.=trace
-# elastic
-spring.elasticsearch.uris=dbrepo-search-db:9200
-
# broker service
spring.rabbitmq.host=dbrepo-broker-service
spring.rabbitmq.virtual-host=/
@@ -33,5 +30,4 @@ spring.rabbitmq.password=guest
# search service
fda.consumers=2
-fda.gateway.endpoint: http://localhost:15672
-fda.elastic.endpoint=dbrepo-search-db:9200
\ No newline at end of file
+fda.gateway.endpoint: http://localhost:15672
\ No newline at end of file
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/musicology.sql b/dbrepo-query-service/rest-service/src/test/resources/init/musicology.sql
new file mode 100644
index 0000000000000000000000000000000000000000..4d2c8deb43ede5de84cd321a302e97ef84038508
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/musicology.sql
@@ -0,0 +1,18 @@
+CREATE DATABASE musicology;
+USE musicology;
+
+CREATE SEQUENCE seq_mfcc;
+
+CREATE TABLE mfcc
+(
+ id BIGINT PRIMARY KEY NOT NULL DEFAULT nextval(`seq_mfcc`),
+ value DECIMAL NOT NULL
+) WITH SYSTEM VERSIONING;
+
+INSERT INTO `mfcc` (`value`)
+VALUES (11.2),
+ (11.3),
+ (11.4),
+ (11.9),
+ (12.3),
+ (23.1);
\ No newline at end of file
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/querystore.sql b/dbrepo-query-service/rest-service/src/test/resources/init/querystore.sql
new file mode 100644
index 0000000000000000000000000000000000000000..1bf8b26c5580b343a7e75864931f2f8584932843
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/querystore.sql
@@ -0,0 +1,5 @@
+CREATE SEQUENCE `qs_queries_seq`;
+CREATE TABLE `qs_queries` ( `id` bigint not null primary key default nextval(`qs_queries_seq`), `created` datetime not null default now(), `executed` datetime not null default now(), `created_by` varchar(255) not null, `query` text not null, `query_normalized` text not null, `is_persisted` boolean not null, `query_hash` varchar(255) not null, `result_hash` varchar(255), `result_number` bigint );
+CREATE PROCEDURE hash_table(IN name VARCHAR(255), OUT hash VARCHAR(255), OUT count BIGINT) BEGIN DECLARE _sql TEXT; SELECT CONCAT('SELECT SHA2(GROUP_CONCAT(CONCAT_WS(\'\',', GROUP_CONCAT(CONCAT('`', column_name, '`') ORDER BY column_name), ') SEPARATOR \',\'), 256) AS hash, COUNT(*) AS count FROM `', name, '` INTO @hash, @count;') FROM `information_schema`.`columns` WHERE `table_schema` = DATABASE() AND `table_name` = name INTO _sql; PREPARE stmt FROM _sql; EXECUTE stmt; DEALLOCATE PREPARE stmt; SET hash = @hash; SET count = @count; END;
+CREATE PROCEDURE store_query(IN query TEXT, IN executed DATETIME, OUT queryId BIGINT) BEGIN DECLARE _queryhash varchar(255) DEFAULT SHA2(query, 256); DECLARE _username varchar(255) DEFAULT REGEXP_REPLACE(current_user(), '@.*', ''); DECLARE _query TEXT DEFAULT CONCAT('CREATE OR REPLACE TABLE _tmp AS (', query, ')'); PREPARE stmt FROM _query; EXECUTE stmt; DEALLOCATE PREPARE stmt; CALL hash_table('_tmp', @hash, @count); IF @hash IS NULL THEN INSERT INTO `qs_queries` (`created_by`, `query`, `query_normalized`, `is_persisted`, `query_hash`, `result_hash`, `result_number`, `executed`) SELECT _username, query, query, false, _queryhash, @hash, @count, executed WHERE NOT EXISTS (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` IS NULL); SET queryId = (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` IS NULL); ELSE INSERT INTO `qs_queries` (`created_by`, `query`, `query_normalized`, `is_persisted`, `query_hash`, `result_hash`, `result_number`, `executed`) SELECT _username, query, query, false, _queryhash, @hash, @count, executed WHERE NOT EXISTS (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` = @hash); SET queryId = (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` = @hash); END IF; END;
+CREATE DEFINER = 'root' PROCEDURE _store_query(IN _username VARCHAR(255), IN query TEXT, IN executed DATETIME, OUT queryId BIGINT) BEGIN DECLARE _queryhash varchar(255) DEFAULT SHA2(query, 256); DECLARE _query TEXT DEFAULT CONCAT('CREATE OR REPLACE TABLE _tmp AS (', query, ')'); PREPARE stmt FROM _query; EXECUTE stmt; DEALLOCATE PREPARE stmt; CALL hash_table('_tmp', @hash, @count); IF @hash IS NULL THEN INSERT INTO `qs_queries` (`created_by`, `query`, `query_normalized`, `is_persisted`, `query_hash`, `result_hash`, `result_number`, `executed`) SELECT _username, query, query, false, _queryhash, @hash, @count, executed WHERE NOT EXISTS (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` IS NULL); SET queryId = (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` IS NULL); ELSE INSERT INTO `qs_queries` (`created_by`, `query`, `query_normalized`, `is_persisted`, `query_hash`, `result_hash`, `result_number`, `executed`) SELECT _username, query, query, false, _queryhash, @hash, @count, executed WHERE NOT EXISTS (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` = @hash); SET queryId = (SELECT `id` FROM `qs_queries` WHERE `query_hash` = _queryhash AND `result_hash` = @hash); END IF; END;
\ No newline at end of file
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/schema.sql b/dbrepo-query-service/rest-service/src/test/resources/init/schema.sql
new file mode 100644
index 0000000000000000000000000000000000000000..f8482e47d5b0827e87537d940b54900a8f2d8f3b
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/schema.sql
@@ -0,0 +1 @@
+CREATE SCHEMA IF NOT EXISTS fda;
\ No newline at end of file
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/users.sql b/dbrepo-query-service/rest-service/src/test/resources/init/users.sql
new file mode 100644
index 0000000000000000000000000000000000000000..45f7b53a0f602a780522da646d64da2a0bc36e53
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/users.sql
@@ -0,0 +1,4 @@
+CREATE USER junit1 IDENTIFIED BY 'junit1';
+CREATE USER junit2 IDENTIFIED BY 'junit2';
+CREATE USER junit3 IDENTIFIED BY 'junit3';
+CREATE USER junit4 IDENTIFIED BY 'junit4';
\ No newline at end of file
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/weather.sql b/dbrepo-query-service/rest-service/src/test/resources/init/weather.sql
new file mode 100644
index 0000000000000000000000000000000000000000..3923462189b4504b88b8599a009b0db4ee3c38d1
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/weather.sql
@@ -0,0 +1,70 @@
+/* https://www.kaggle.com/jsphyg/weather-dataset-rattle-package */
+CREATE DATABASE weather;
+USE weather;
+
+CREATE TABLE weather_location
+(
+ location VARCHAR(255) PRIMARY KEY,
+ lat DOUBLE PRECISION NULL,
+ lng DOUBLE PRECISION NULL
+) WITH SYSTEM VERSIONING;
+
+CREATE TABLE weather_aus
+(
+ id BIGINT NOT NULL PRIMARY KEY,
+ `date` DATE NOT NULL,
+ location VARCHAR(255) NULL,
+ mintemp DOUBLE PRECISION NULL,
+ rainfall DOUBLE PRECISION NULL,
+ FOREIGN KEY (location) REFERENCES weather_location (location),
+ UNIQUE (`date`),
+ CHECK (`mintemp` > 0)
+) WITH SYSTEM VERSIONING;
+
+CREATE TABLE sensor
+(
+ `timestamp` TIMESTAMP NOT NULL PRIMARY KEY,
+ `value` DECIMAL
+) WITH SYSTEM VERSIONING;
+
+INSERT INTO weather_location (location, lat, lng)
+VALUES ('Albury', -36.0653583, 146.9112214),
+ ('Sydney', -33.847927, 150.6517942),
+ ('Vienna', null, null);
+
+INSERT INTO weather_aus (id, `date`, location, mintemp, rainfall)
+VALUES (1, '2008-12-01', 'Albury', 13.4, 0.6),
+ (2, '2008-12-02', 'Albury', 7.4, 0),
+ (3, '2008-12-03', 'Albury', 12.9, 0);
+
+INSERT INTO sensor (`timestamp`, value)
+VALUES ('2022-12-24 17:00:00', 10.0),
+ ('2022-12-24 18:00:00', 10.2),
+ ('2022-12-24 19:00:00', null),
+ ('2022-12-24 20:00:00', 10.3),
+ ('2022-12-24 21:00:00', 10.0),
+ ('2022-12-24 22:00:00', null);
+
+/*
+########################################################################################################################
+## TEST CASE PRE-REQUISITE ##
+########################################################################################################################
+*/
+
+CREATE VIEW junit2 AS
+(
+select `date`, `location`, `mintemp`, `rainfall`
+from `weather_aus`
+where `location` = 'Albury');
+
+CREATE VIEW `hs_weather_aus` AS
+SELECT *
+FROM (SELECT `id`, ROW_START AS inserted_at, IF(ROW_END > NOW(), NULL, ROW_END) AS deleted_at, COUNT(*) as total
+ FROM `weather_aus` FOR SYSTEM_TIME ALL
+ GROUP BY inserted_at, deleted_at
+ ORDER BY deleted_at DESC
+ LIMIT 50) AS v
+ORDER BY v.inserted_at, v.deleted_at ASC;
+
+
+COMMIT;
diff --git a/dbrepo-query-service/rest-service/src/test/resources/init/zoo.sql b/dbrepo-query-service/rest-service/src/test/resources/init/zoo.sql
new file mode 100644
index 0000000000000000000000000000000000000000..bcf46ea5703265d4574a0dda121d6c38b9430798
--- /dev/null
+++ b/dbrepo-query-service/rest-service/src/test/resources/init/zoo.sql
@@ -0,0 +1,199 @@
+CREATE DATABASE zoo;
+USE zoo;
+
+create sequence seq_zoo_id;
+create sequence seq_names_id;
+create table zoo
+(
+ id bigint not null default nextval(`seq_zoo_id`),
+ animal_name varchar(255) null,
+ hair tinyint(1) null,
+ feathers tinyint(1) null,
+ eggs tinyint(1) null,
+ milk tinyint(1) null,
+ airborne tinyint(1) null,
+ aquatic tinyint(1) null,
+ predator tinyint(1) null,
+ toothed tinyint(1) null,
+ backbone tinyint(1) null,
+ breathes tinyint(1) null,
+ venomous tinyint(1) null,
+ fins tinyint(1) null,
+ legs bigint null,
+ tail tinyint(1) null,
+ domestic tinyint(1) null,
+ catsize tinyint(1) null,
+ class_type bigint null,
+ primary key (id)
+) with system versioning;
+
+create table names
+(
+ id bigint not null default nextval(`seq_names_id`),
+ firstname varchar(255),
+ lastname varchar(255),
+ primary key (id),
+ unique key (firstname, lastname)
+) with system versioning;
+
+create table likes
+(
+ name_id bigint not null,
+ zoo_id bigint not null,
+ primary key (name_id, zoo_id),
+ foreign key (name_id) references names (id),
+ foreign key (zoo_id) references zoo (id)
+) with system versioning;
+
+INSERT INTO zoo (id, animal_name, hair, feathers, eggs, milk, airborne, aquatic, predator, toothed, backbone, breathes,
+ venomous, fins, legs, tail, domestic, catsize, class_type)
+VALUES (1, 'aardvark', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 0, 0, 1, 1),
+ (2, 'antelope', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (3, 'bass', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (4, 'bear', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 0, 0, 1, 1),
+ (5, 'boar', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (6, 'buffalo', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (7, 'calf', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 1, 1, 1),
+ (8, 'carp', 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 4),
+ (9, 'catfish', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (10, 'cavy', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 0, 1, 0, 1),
+ (11, 'cheetah', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (12, 'chicken', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 1, 0, 2),
+ (13, 'chub', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (14, 'clam', 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7),
+ (15, 'crab', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 0, 0, 7),
+ (16, 'crayfish', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 6, 0, 0, 0, 7),
+ (17, 'crow', 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (18, 'deer', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (19, 'dogfish', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 4),
+ (20, 'dolphin', 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1),
+ (21, 'dove', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 1, 0, 2),
+ (22, 'duck', 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (23, 'elephant', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (24, 'flamingo', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (25, 'flea', 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (26, 'frog', 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 4, 0, 0, 0, 5),
+ (27, 'frog', 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 4, 0, 0, 0, 5),
+ (28, 'fruitbat', 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 2, 1, 0, 0, 1),
+ (29, 'giraffe', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (30, 'girl', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 2, 0, 1, 1, 1),
+ (31, 'gnat', 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (32, 'goat', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 1, 1, 1),
+ (33, 'gorilla', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 2, 0, 0, 1, 1),
+ (34, 'gull', 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (35, 'haddock', 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (36, 'hamster', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 1, 0, 1),
+ (37, 'hare', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 0, 1),
+ (38, 'hawk', 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (39, 'herring', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (40, 'honeybee', 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 6, 0, 1, 0, 6),
+ (41, 'housefly', 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (42, 'kiwi', 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (43, 'ladybird', 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (44, 'lark', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (45, 'leopard', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (46, 'lion', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (47, 'lobster', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 6, 0, 0, 0, 7),
+ (48, 'lynx', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (49, 'mink', 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (50, 'mole', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 0, 1),
+ (51, 'mongoose', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (52, 'moth', 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (53, 'newt', 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 4, 1, 0, 0, 5),
+ (54, 'octopus', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 8, 0, 0, 1, 7),
+ (55, 'opossum', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 0, 1),
+ (56, 'oryx', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (57, 'ostrich', 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (58, 'parakeet', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 1, 0, 2),
+ (59, 'penguin', 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (60, 'pheasant', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (61, 'pike', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 4),
+ (62, 'piranha', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (63, 'pitviper', 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 3),
+ (64, 'platypus', 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (65, 'polecat', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (66, 'pony', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 1, 1, 1),
+ (67, 'porpoise', 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1),
+ (68, 'puma', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (69, 'pussycat', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 1, 1, 1),
+ (70, 'raccoon', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (71, 'reindeer', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 1, 1, 1),
+ (72, 'rhea', 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (73, 'scorpion', 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 8, 1, 0, 0, 7),
+ (74, 'seahorse', 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (75, 'seal', 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1),
+ (76, 'sealion', 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1),
+ (77, 'seasnake', 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 3),
+ (78, 'seawasp', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 7),
+ (79, 'skimmer', 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (80, 'skua', 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (81, 'slowworm', 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 3),
+ (82, 'slug', 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 7),
+ (83, 'sole', 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 4),
+ (84, 'sparrow', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2),
+ (85, 'squirrel', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 2, 1, 0, 0, 1),
+ (86, 'starfish', 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 5, 0, 0, 0, 7),
+ (87, 'stingray', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 4),
+ (88, 'swan', 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (89, 'termite', 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 6, 0, 0, 0, 6),
+ (90, 'toad', 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 4, 0, 0, 0, 5),
+ (91, 'tortoise', 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 4, 1, 0, 1, 3),
+ (92, 'tuatara', 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 0, 3),
+ (93, 'tuna', 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 4),
+ (94, 'vampire', 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 2, 1, 0, 0, 1),
+ (95, 'vole', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 0, 1),
+ (96, 'vulture', 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 1, 2),
+ (97, 'wallaby', 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 2, 1, 0, 1, 1),
+ (98, 'wasp', 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 6, 0, 0, 0, 6),
+ (99, 'wolf', 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 4, 1, 0, 1, 1),
+ (100, 'worm', 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 7),
+ (101, 'wren', 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 2, 1, 0, 0, 2);
+
+INSERT INTO names (firstname, lastname)
+VALUES ('Moritz', 'Staudinger'),
+ ('Martin', 'Weise'),
+ ('Eva', 'Gergely'),
+ ('Cornelia', 'Michlits'),
+ ('Kirill', 'Stytsenko');
+
+INSERT INTO likes (name_id, zoo_id)
+VALUES (1, 5),
+ (1, 10),
+ (2, 3),
+ (2, 80),
+ (3, 4),
+ (4, 4),
+ (5, 100);
+
+/*
+########################################################################################################################
+## TEST CASE PRE-REQUISITE ##
+########################################################################################################################
+*/
+
+CREATE VIEW mock_view AS
+(
+SELECT `id`,
+ `animal_name`,
+ `hair`,
+ `feathers`,
+ `eggs`,
+ `milk`,
+ `airborne`,
+ `aquatic`,
+ `predator`,
+ `toothed`,
+ `backbone`,
+ `breathes`,
+ `venomous`,
+ `fins`,
+ `legs`,
+ `tail`,
+ `domestic`,
+ `catsize`,
+ `class_type`
+FROM `zoo`
+WHERE `class_type` = 1);
+
+
+COMMIT;
diff --git a/dbrepo-query-service/rest-service/src/test/resources/sensor/1_querystore.sql b/dbrepo-query-service/rest-service/src/test/resources/sensor/1_querystore.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/sensor/2_traffic.sql b/dbrepo-query-service/rest-service/src/test/resources/sensor/2_traffic.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/traffic/1_querystore.sql b/dbrepo-query-service/rest-service/src/test/resources/traffic/1_querystore.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/traffic/2_traffic.sql b/dbrepo-query-service/rest-service/src/test/resources/traffic/2_traffic.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/weather/1_querystore.sql b/dbrepo-query-service/rest-service/src/test/resources/weather/1_querystore.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/weather/2_weather.sql b/dbrepo-query-service/rest-service/src/test/resources/weather/2_weather.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/zoo/1_querystore.sql b/dbrepo-query-service/rest-service/src/test/resources/zoo/1_querystore.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/rest-service/src/test/resources/zoo/2_zoo.sql b/dbrepo-query-service/rest-service/src/test/resources/zoo/2_zoo.sql
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/amqp/RabbitMqConsumer.java b/dbrepo-query-service/services/src/main/java/at/tuwien/amqp/RabbitMqConsumer.java
index f7203ac70a4b1bdb7fcbfab13a9cfc42a2cacfe3..0f32e23535458cb25e2e2fc78e21c55f10c74986 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/amqp/RabbitMqConsumer.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/amqp/RabbitMqConsumer.java
@@ -1,7 +1,6 @@
package at.tuwien.amqp;
import at.tuwien.api.database.table.TableCsvDto;
-import at.tuwien.entities.database.table.Table;
import at.tuwien.exception.*;
import at.tuwien.service.QueryService;
import com.fasterxml.jackson.core.type.TypeReference;
@@ -21,15 +20,12 @@ import java.util.HashMap;
@Log4j2
public class RabbitMqConsumer implements Consumer {
- private final Long containerId;
private final Long databaseId;
private final Long tableId;
private final ObjectMapper objectMapper;
private final QueryService queryService;
- public RabbitMqConsumer(Long containerId, Long databaseId, Long tableId, ObjectMapper objectMapper,
- QueryService queryService) {
- this.containerId = containerId;
+ public RabbitMqConsumer(Long databaseId, Long tableId, ObjectMapper objectMapper, QueryService queryService) {
this.databaseId = databaseId;
this.tableId = tableId;
this.objectMapper = objectMapper;
@@ -74,7 +70,7 @@ public class RabbitMqConsumer implements Consumer {
.build();
log.trace("received tuple data {}", data);
try {
- queryService.insert(containerId, databaseId, tableId, data, new BasicUserPrincipal(properties.getUserId()));
+ queryService.insert(databaseId, tableId, data, new BasicUserPrincipal(properties.getUserId()));
} catch (HttpClientErrorException.Unauthorized e) {
log.error("Failed to authenticate for table with id {}, reason: {}", tableId, e.getMessage());
throw new IOException("Failed to authenticate for table", e);
@@ -93,11 +89,8 @@ public class RabbitMqConsumer implements Consumer {
} catch (ImageNotSupportedException e) {
log.error("Image is not supported");
throw new IOException("Image is not supported", e);
- } catch (ContainerNotFoundException e) {
- log.error("Failed to find container with id {}, reason: {}", containerId, e.getMessage());
- throw new IOException("Failed to find container", e);
} catch (DatabaseConnectionException e) {
- log.error("Failed to connect to container with id {}, reason: {}", containerId, e.getMessage());
+ log.error("Failed to connect to database, reason: {}", e.getMessage());
throw new IOException("Failed to connect to container", e);
} catch (UserNotFoundException e) {
log.error("Failed to find user with id {}", properties.getUserId());
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/config/AmqpConfig.java b/dbrepo-query-service/services/src/main/java/at/tuwien/config/AmqpConfig.java
index 4d827c225004a1d1bfe8bb910cca8b4b66da0849..0d2f0d1c1a3f23e16a63b67cad036e2340af36d2 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/config/AmqpConfig.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/config/AmqpConfig.java
@@ -20,6 +20,9 @@ public class AmqpConfig {
@Value("${spring.rabbitmq.host}")
private String ampqHost;
+ @Value("${spring.rabbitmq.port:5672}")
+ private int ampqPort;
+
@Value("${spring.rabbitmq.virtual-host}")
private String virtualHost;
@@ -36,6 +39,7 @@ public class AmqpConfig {
public ConnectionFactory connectionFactory() {
final ConnectionFactory factory = new ConnectionFactory();
factory.setHost(ampqHost);
+ factory.setPort(ampqPort);
factory.setVirtualHost(virtualHost);
factory.setUsername(amqpUsername);
factory.setPassword(amqpPassword);
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/config/WebSecurityConfig.java b/dbrepo-query-service/services/src/main/java/at/tuwien/config/WebSecurityConfig.java
index b6fab51c6dde960603fb8c10d3bea101666c4744..968799322eb990d0b2bd7a23a6c89e5ba8470373 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/config/WebSecurityConfig.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/config/WebSecurityConfig.java
@@ -3,6 +3,7 @@ package at.tuwien.config;
import at.tuwien.auth.AuthTokenFilter;
import io.swagger.v3.oas.annotations.enums.SecuritySchemeType;
import io.swagger.v3.oas.annotations.security.SecurityScheme;
+import jakarta.servlet.http.HttpServletResponse;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
@@ -17,8 +18,6 @@ import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
-import jakarta.servlet.http.HttpServletResponse;
-
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
@@ -45,14 +44,14 @@ public class WebSecurityConfig {
new AntPathRequestMatcher("/swagger-ui.html")
);
final OrRequestMatcher publicEndpoints = new OrRequestMatcher(
- new AntPathRequestMatcher("/api/container/**/database/data/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/table/**/data/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/view/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/table/**/history/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/table/**/export/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/query/**", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/query/**/export", "GET"),
- new AntPathRequestMatcher("/api/container/**/database/**/query/**", "PUT")
+ new AntPathRequestMatcher("/api/database/data/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/table/**/data/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/view/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/table/**/history/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/table/**/export/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/query/**", "GET"),
+ new AntPathRequestMatcher("/api/database/**/query/**/export", "GET"),
+ new AntPathRequestMatcher("/api/database/**/query/**", "PUT")
);
/* enable CORS and disable CSRF */
http = http.cors().and().csrf().disable();
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/DatabaseMapper.java b/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/DatabaseMapper.java
deleted file mode 100644
index 88d98a6706542a938cdd6962b053ab2e6b054090..0000000000000000000000000000000000000000
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/DatabaseMapper.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package at.tuwien.mapper;
-
-import at.tuwien.entities.container.Container;
-import at.tuwien.entities.container.image.ContainerImageEnvironmentItem;
-import at.tuwien.entities.container.image.ContainerImageEnvironmentItemType;
-import at.tuwien.entities.user.User;
-import org.mapstruct.Mapper;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.stream.Collectors;
-
-@Mapper(componentModel = "spring")
-public interface DatabaseMapper {
-
- org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DatabaseMapper.class);
-
- @Transactional(readOnly = true)
- default User containerToPrivilegedUser(Container container) {
- final String username = container.getImage()
- .getEnvironment()
- .stream()
- .filter(e -> e.getType().equals(ContainerImageEnvironmentItemType.PRIVILEGED_USERNAME))
- .map(ContainerImageEnvironmentItem::getValue)
- .collect(Collectors.toList())
- .get(0);
- final String password = container.getImage()
- .getEnvironment()
- .stream()
- .filter(e -> e.getType().equals(ContainerImageEnvironmentItemType.PRIVILEGED_PASSWORD))
- .map(ContainerImageEnvironmentItem::getValue)
- .collect(Collectors.toList())
- .get(0);
- return User.builder()
- .username(username)
- .databasePassword(password)
- .build();
- }
-
-}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/QueryMapper.java b/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/QueryMapper.java
index 63acb8522ac273f7cf0400d0876502284acb9dd2..471403d424eb37f4ffe2b881a606a46b09910d44 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/QueryMapper.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/mapper/QueryMapper.java
@@ -1,20 +1,23 @@
package at.tuwien.mapper;
-import at.tuwien.api.database.query.*;
+import at.tuwien.api.database.query.ImportDto;
+import at.tuwien.api.database.query.QueryBriefDto;
+import at.tuwien.api.database.query.QueryDto;
+import at.tuwien.api.database.query.QueryResultDto;
import at.tuwien.api.database.table.TableCsvDeleteDto;
import at.tuwien.api.database.table.TableCsvDto;
import at.tuwien.api.database.table.TableCsvUpdateDto;
import at.tuwien.api.database.table.TableHistoryDto;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.database.View;
+import at.tuwien.entities.database.table.Table;
+import at.tuwien.entities.database.table.columns.TableColumn;
import at.tuwien.entities.database.table.columns.TableColumnType;
+import at.tuwien.exception.ImageNotSupportedException;
import at.tuwien.exception.QueryMalformedException;
import at.tuwien.exception.QueryStoreException;
import at.tuwien.exception.TableMalformedException;
import at.tuwien.querystore.Query;
-import at.tuwien.entities.database.table.Table;
-import at.tuwien.entities.database.table.columns.TableColumn;
-import at.tuwien.exception.ImageNotSupportedException;
import net.sf.jsqlparser.statement.select.SelectItem;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
@@ -24,8 +27,8 @@ import org.mariadb.jdbc.MariaDbBlob;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigInteger;
-import java.sql.*;
import java.sql.Date;
+import java.sql.*;
import java.text.Normalizer;
import java.time.*;
import java.time.format.DateTimeFormatter;
@@ -402,7 +405,7 @@ public interface QueryMapper {
throw new TableMalformedException("Columns are not known");
}
/* check image */
- if (!table.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!table.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Image not supported.");
}
@@ -461,7 +464,7 @@ public interface QueryMapper {
throw new TableMalformedException("Columns are not known");
}
/* check image */
- if (!table.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!table.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Image not supported.");
}
@@ -508,7 +511,7 @@ public interface QueryMapper {
throw new TableMalformedException("Columns are not known");
}
/* check image */
- if (!table.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!table.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Image not supported.");
}
@@ -579,7 +582,7 @@ public interface QueryMapper {
throws ImageNotSupportedException {
log.trace("mapping table to raw count query, table={}, timestamp={}", table, timestamp);
/* check image */
- if (!table.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!table.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Image not supported.");
}
@@ -594,7 +597,7 @@ public interface QueryMapper {
throws ImageNotSupportedException {
log.trace("mapping table to raw count query, view={}", view);
/* check image */
- if (!view.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!view.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Image not supported.");
}
@@ -619,7 +622,7 @@ public interface QueryMapper {
log.trace("mapping query to timestamped query, query={}, database={}, timestamp={}, selection={}, page={}, size={}",
query, database, timestamp, selection, page, size);
/* param check */
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
@@ -678,7 +681,7 @@ public interface QueryMapper {
log.trace("mapping table to find all query, table={}, timestamp={}, size={}, page={}",
table, timestamp, size, page);
/* param check */
- if (!table.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!table.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
@@ -695,7 +698,7 @@ public interface QueryMapper {
throws ImageNotSupportedException {
log.trace("mapping view to find all query, view={}, size={}, page={}", view, size, page);
/* param check */
- if (!view.getDatabase().getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!view.getDatabase().getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/DatabaseRepository.java b/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/DatabaseRepository.java
index e5b21ce646cb8999a801aeeacd36214449c6f301..ae627d68aa707c67cbee40d8fa74c1f13670382a 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/DatabaseRepository.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/DatabaseRepository.java
@@ -11,8 +11,8 @@ import java.util.Optional;
@Repository
public interface DatabaseRepository extends JpaRepository<Database, Long> {
- @Query(value = "select d from Database d where d.container.id = :containerId and d.id = :databaseId")
- Optional<Database> findByContainerIdAndDatabaseId(@Param("containerId") Long containerId, @Param("databaseId") Long databaseId);
+ @Query(value = "select d from Database d where d.id = :databaseId")
+ Optional<Database> findByDatabaseId(@Param("databaseId") Long databaseId);
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/TableRepository.java b/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/TableRepository.java
index e4fe63d6239ceae9c9063e96a9533ad3a746f6da..3a85db25884cf7a8f2f2d4b85c2cab53195af4f9 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/TableRepository.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/repository/mdb/TableRepository.java
@@ -12,8 +12,7 @@ import java.util.Optional;
@Repository
public interface TableRepository extends JpaRepository<Table, TableKey> {
- @Query(value = "select t from Table t where t.database.container.id = :containerId and t.database.id = :databaseId and t.id = :tableId")
- Optional<Table> find(@Param("containerId") Long containerId, @Param("databaseId") Long databaseId,
- @Param("tableId") Long tableId);
+ @Query(value = "select t from Table t where t.database.id = :databaseId and t.id = :tableId")
+ Optional<Table> find(@Param("databaseId") Long databaseId, @Param("tableId") Long tableId);
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/DatabaseService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/DatabaseService.java
index 80694cf22f956a0d2aaae2f56d129c8bffd2fd07..52009936dc771e3e13f2bab2450d87293fcfe8bf 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/DatabaseService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/DatabaseService.java
@@ -2,7 +2,6 @@ package at.tuwien.service;
import at.tuwien.entities.database.Database;
import at.tuwien.exception.DatabaseNotFoundException;
-import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@@ -11,12 +10,11 @@ public interface DatabaseService {
/**
* Finds a database by given id in the metadata database.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @return The database.
* @throws DatabaseNotFoundException The database was not found.
*/
- Database find(Long containerId, Long databaseId) throws DatabaseNotFoundException;
+ Database find(Long databaseId) throws DatabaseNotFoundException;
/**
* Finds all databases stored in the metadata database.
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/MessageQueueService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/MessageQueueService.java
index ed4342ddd40cfda326958f0b23fab34b30fc8583..b9223bf99ecdf30c42b4f1bb281fc6d2da7ffd2f 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/MessageQueueService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/MessageQueueService.java
@@ -1,6 +1,5 @@
package at.tuwien.service;
-import at.tuwien.entities.database.table.Table;
import at.tuwien.exception.AmqpException;
public interface MessageQueueService {
@@ -9,12 +8,11 @@ public interface MessageQueueService {
* Creates a consumer on the provided queue with name and container id and database id for table id.
*
* @param queueName The queue name.
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @throws AmqpException The consumer could not be created.
*/
- void createConsumer(String queueName, Long containerId, Long databaseId, Long tableId) throws AmqpException;
+ void createConsumer(String queueName, Long databaseId, Long tableId) throws AmqpException;
/**
* Restores missing consumers at the Broker Service.
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/QueryService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/QueryService.java
index b975235b5b144bcc1201083e4c1e3651e70d3d9d..ccd997e773976efc369b5642d1bfe76d626d78bc 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/QueryService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/QueryService.java
@@ -24,10 +24,9 @@ import java.util.List;
public interface QueryService {
/**
- * Executes an arbitrary query on the database container. We allow the user to only view the data, therefore the
+ * Executes an arbitrary query on the database. We allow the user to only view the data, therefore the
* default "mariadb" user is allowed read-only access "SELECT".
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param statement The query.
* @param principal The current user.
@@ -40,20 +39,18 @@ public interface QueryService {
* @throws QueryMalformedException The query is malformed.
* @throws DatabaseNotFoundException The database was not found in the metdata database.
* @throws ImageNotSupportedException The image is not supported.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws QueryMalformedException The query is malformed.
*/
- QueryResultDto execute(Long containerId, Long databaseId, ExecuteStatementDto statement,
+ QueryResultDto execute(Long databaseId, ExecuteStatementDto statement,
Principal principal, Long page, Long size,
SortType sortDirection, String sortColumn) throws DatabaseNotFoundException,
- ImageNotSupportedException, QueryMalformedException, QueryStoreException, ContainerNotFoundException,
+ ImageNotSupportedException, QueryMalformedException, QueryStoreException,
ColumnParseException, UserNotFoundException, TableMalformedException, DatabaseConnectionException;
/**
- * Re-Executes an arbitrary query on the database container. We allow the user to only view the data, therefore the
+ * Re-Executes an arbitrary query on the database. We allow the user to only view the data, therefore the
* default "mariadb" user is allowed read-only access "SELECT".
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param query The query.
* @param page The page number.
@@ -70,16 +67,15 @@ public interface QueryService {
* @throws ColumnParseException The column mapping/parsing failed.
* @throws QueryMalformedException The query is malformed.
*/
- QueryResultDto reExecute(Long containerId, Long databaseId, Query query, Long page, Long size,
+ QueryResultDto reExecute(Long databaseId, Query query, Long page, Long size,
SortType sortDirection, String sortColumn, Principal principal)
throws QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ColumnParseException,
DatabaseConnectionException, TableMalformedException, QueryStoreException, UserNotFoundException;
/**
- * Re-Executes the count-statement of an arbitrary query on the database container. We allow the user to only view
+ * Re-Executes the count-statement of an arbitrary query on the database. We allow the user to only view
* the data, therefore the default "mariadb" user is allowed read-only access "SELECT".
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param query The query.
* @param principal The user principal.
@@ -91,7 +87,7 @@ public interface QueryService {
* @throws TableMalformedException The table is malformed.
* @throws ColumnParseException The column mapping/parsing failed.
*/
- Long reExecuteCount(Long containerId, Long databaseId, Query query, Principal principal)
+ Long reExecuteCount(Long databaseId, Query query, Principal principal)
throws QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ColumnParseException,
TableMalformedException, QueryStoreException;
@@ -99,8 +95,7 @@ public interface QueryService {
* Select all data known in the database-table id tuple at a given time and return a page of specific size, using
* Instant to better abstract time concept (JDK 8) from SQL. We use the "mariadb" user for this.
*
- * @param containerId The container-database id pair.
- * @param databaseId The container-database id pair.
+ * @param databaseId The database id.
* @param tableId The table id.
* @param timestamp The given time.
* @param page The page.
@@ -110,27 +105,24 @@ public interface QueryService {
* @throws TableNotFoundException The table was not found in the metadata database.
* @throws DatabaseNotFoundException The database was not found in the metdata database.
* @throws ImageNotSupportedException The image is not supported.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws TableMalformedException The table is malformed.
* @throws QueryMalformedException The query is malformed.
*/
- QueryResultDto tableFindAll(Long containerId, Long databaseId, Long tableId, Instant timestamp,
+ QueryResultDto tableFindAll(Long databaseId, Long tableId, Instant timestamp,
Long page, Long size, Principal principal) throws TableNotFoundException, DatabaseNotFoundException,
ImageNotSupportedException, DatabaseConnectionException, TableMalformedException, PaginationException,
- ContainerNotFoundException, QueryMalformedException, UserNotFoundException;
+ QueryMalformedException, UserNotFoundException;
/**
* Select all data known in the database-table id tuple at a given time and return a downloadable input stream
* resource at a given time. Instant to better abstract time concept (JDK 8) from SQL. We use the "mariadb" user
* for this.
*
- * @param containerId The container-database id pair.
- * @param databaseId The container-database id pair.
+ * @param databaseId The database id.
* @param tableId The table id.
* @param timestamp The given time.
* @param principal The user principal.
* @return The select all data result in the form of a downloadable .csv file.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws TableNotFoundException The table was not found in the metadata database.
* @throws TableMalformedException The table columns are messed up what we got from the metadata database.
* @throws DatabaseNotFoundException The database was not found in the remote database.
@@ -139,17 +131,16 @@ public interface QueryService {
* @throws FileStorageException The file could not be exported.
* @throws QueryMalformedException The query is malformed.
*/
- ExportResource tableFindAll(Long containerId, Long databaseId, Long tableId, Instant timestamp, Principal principal)
+ ExportResource tableFindAll(Long databaseId, Long tableId, Instant timestamp, Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, ImageNotSupportedException,
- DatabaseConnectionException, TableMalformedException, PaginationException, ContainerNotFoundException,
+ DatabaseConnectionException, TableMalformedException, PaginationException,
FileStorageException, QueryMalformedException, UserNotFoundException;
/**
* Select all data known in the view id tuple and return a page of specific size.
* We use the "mariadb" user for this.
*
- * @param containerId The container-database id pair.
- * @param databaseId The container-database id pair.
+ * @param databaseId The database id.
* @param view The view.
* @param page The page.
* @param size The page size.
@@ -158,19 +149,17 @@ public interface QueryService {
* @throws ViewNotFoundException The view was not found in the metadata database.
* @throws DatabaseNotFoundException The database was not found in the metdata database.
* @throws ImageNotSupportedException The image is not supported.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws ViewMalformedException The table is malformed.
* @throws QueryMalformedException The query is malformed.
*/
- QueryResultDto viewFindAll(Long containerId, Long databaseId, View view,
+ QueryResultDto viewFindAll(Long databaseId, View view,
Long page, Long size, Principal principal) throws ViewNotFoundException, DatabaseNotFoundException,
ImageNotSupportedException, DatabaseConnectionException, ViewMalformedException, PaginationException,
- ContainerNotFoundException, QueryMalformedException, UserNotFoundException, TableMalformedException;
+ QueryMalformedException, UserNotFoundException, TableMalformedException;
/**
- * Finds one query by container-database-query triple.
+ * Finds one query by database id and query id.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param queryId The query id.
* @param principal The user principal.
@@ -178,54 +167,46 @@ public interface QueryService {
* @throws DatabaseNotFoundException The database was not found in the remote database.
* @throws ImageNotSupportedException The image is not supported.
* @throws TableMalformedException The table columns are messed up what we got from the metadata database.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws FileStorageException The file could not be exported.
* @throws QueryStoreException The query store is not reachable.
* @throws QueryNotFoundException THe query was not found in the query store.
* @throws QueryMalformedException The query is malformed.
*/
- ExportResource findOne(Long containerId, Long databaseId, Long queryId, Principal principal)
+ ExportResource findOne(Long databaseId, Long queryId, Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException, TableMalformedException,
- ContainerNotFoundException, FileStorageException, QueryStoreException, QueryNotFoundException, QueryMalformedException, DatabaseConnectionException, UserNotFoundException;
+ FileStorageException, QueryStoreException, QueryNotFoundException, QueryMalformedException, DatabaseConnectionException, UserNotFoundException;
/**
- * Count the total tuples for a given table id within a container-database id tuple at a given time.
+ * Count the total tuples for a given table id within a database id at a given time.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @param timestamp The time.
* @param principal The user principal.
* @return The number of records, if successful
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws DatabaseNotFoundException The database was not found in the remote database.
* @throws TableNotFoundException The table was not found in the metadata database.
* @throws TableMalformedException The table columns are messed up what we got from the metadata database.
* @throws ImageNotSupportedException The image is not supported.
*/
- Long tableCount(Long containerId, Long databaseId, Long tableId, Instant timestamp, Principal principal)
- throws ContainerNotFoundException, DatabaseNotFoundException, TableNotFoundException,
- TableMalformedException, ImageNotSupportedException, DatabaseConnectionException, QueryMalformedException, QueryStoreException, UserNotFoundException;
+ Long tableCount(Long databaseId, Long tableId, Instant timestamp, Principal principal)
+ throws DatabaseNotFoundException, TableNotFoundException, TableMalformedException, ImageNotSupportedException, DatabaseConnectionException, QueryMalformedException, QueryStoreException, UserNotFoundException;
/**
- * Count the total tuples for a given table id within a container-database id tuple at a given time.
+ * Count the total tuples for a given table id within a database id at a given time.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param view The view.
* @param principal The user principal.
* @return The number of records, if successful
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws DatabaseNotFoundException The database was not found in the remote database.
* @throws TableMalformedException The view columns are messed up what we got from the metadata database.
* @throws ImageNotSupportedException The image is not supported.
*/
- Long viewCount(Long containerId, Long databaseId, View view, Principal principal)
- throws ContainerNotFoundException, DatabaseNotFoundException,
- TableMalformedException, ImageNotSupportedException, DatabaseConnectionException, QueryMalformedException, QueryStoreException, UserNotFoundException;
+ Long viewCount(Long databaseId, View view, Principal principal)
+ throws DatabaseNotFoundException, TableMalformedException, ImageNotSupportedException, DatabaseConnectionException, QueryMalformedException, QueryStoreException, UserNotFoundException;
/**
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @param data
@@ -238,7 +219,7 @@ public interface QueryService {
* @throws QueryMalformedException The query is malformed.
*/
@Deprecated
- void update(Long containerId, Long databaseId, Long tableId, TableCsvUpdateDto data, Principal principal)
+ void update(Long databaseId, Long tableId, TableCsvUpdateDto data, Principal principal)
throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
TableNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException;
@@ -246,7 +227,6 @@ public interface QueryService {
* Insert data from AMQP client into a table of a table-database id tuple, we need the "root" role for this as the
* default "mariadb" user is configured to only be allowed to execute "SELECT" statements.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @param data The data.
@@ -255,15 +235,13 @@ public interface QueryService {
* @throws TableMalformedException The table does not exist in the metadata database.
* @throws DatabaseNotFoundException The database is not found in the metadata database.
* @throws TableNotFoundException The table is not found in the metadata database.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
*/
- void insert(Long containerId, Long databaseId, Long tableId, TableCsvDto data, Principal principal) throws ImageNotSupportedException,
- TableMalformedException, DatabaseNotFoundException, TableNotFoundException, ContainerNotFoundException, DatabaseConnectionException, UserNotFoundException;
+ void insert(Long databaseId, Long tableId, TableCsvDto data, Principal principal) throws ImageNotSupportedException,
+ TableMalformedException, DatabaseNotFoundException, TableNotFoundException, DatabaseConnectionException, UserNotFoundException;
/**
* Deletes a tuple by given constraint set
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @param data The constraint set.
@@ -274,9 +252,9 @@ public interface QueryService {
* @throws TableNotFoundException The table is not found in the metadata database.
* @throws QueryMalformedException The query is malformed.
*/
- void delete(Long containerId, Long databaseId, Long tableId, TableCsvDeleteDto data, Principal principal)
+ void delete(Long databaseId, Long tableId, TableCsvDeleteDto data, Principal principal)
throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
- TableNotFoundException, ContainerNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException;
+ TableNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException;
/**
* Insert data from a csv into a table of a table-database id tuple, we need the "root" role for this as the
@@ -290,11 +268,10 @@ public interface QueryService {
* @throws TableMalformedException The table does not exist in the metadata database.
* @throws DatabaseNotFoundException The database is not found in the metadata database.
* @throws TableNotFoundException The table is not found in the metadata database.
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws QueryMalformedException The query is malformed.
*/
- void insert(Long containerId, Long databaseId, Long tableId, ImportDto data, Principal principal) throws ImageNotSupportedException,
- TableMalformedException, DatabaseNotFoundException, TableNotFoundException, ContainerNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException;
+ void insert(Long databaseId, Long tableId, ImportDto data, Principal principal) throws ImageNotSupportedException,
+ TableMalformedException, DatabaseNotFoundException, TableNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException;
/**
* Parses the stored columns from a given query.
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/StoreService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/StoreService.java
index 1df5336c91f4a98609d072c8a2d0bc655a2dbf89..78729069ff1d34f75094f4b5e1deb2b639b1bb6a 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/StoreService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/StoreService.java
@@ -1,15 +1,11 @@
package at.tuwien.service;
import at.tuwien.api.database.query.ExecuteStatementDto;
-import at.tuwien.api.database.query.QueryResultDto;
-import at.tuwien.api.database.query.QueryTypeDto;
import at.tuwien.exception.*;
import at.tuwien.querystore.Query;
import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
import java.security.Principal;
-import java.time.Instant;
import java.util.List;
@Service
@@ -26,7 +22,7 @@ public interface StoreService {
* @throws DatabaseNotFoundException The database was not found in the metadata database
* @throws QueryStoreException The query store produced an invalid result
*/
- List<Query> findAll(Long containerId, Long databaseId, Boolean persisted, Principal principal) throws DatabaseNotFoundException,
+ List<Query> findAll(Long databaseId, Boolean persisted, Principal principal) throws DatabaseNotFoundException,
ImageNotSupportedException, QueryStoreException, ContainerNotFoundException, DatabaseConnectionException,
TableMalformedException, UserNotFoundException;
@@ -42,13 +38,12 @@ public interface StoreService {
* @throws QueryStoreException The query store produced an invalid result
* @throws QueryNotFoundException The query store did not return a query
*/
- Query findOne(Long containerId, Long databaseId, Long queryId, Principal principal) throws DatabaseNotFoundException,
+ Query findOne(Long databaseId, Long queryId, Principal principal) throws DatabaseNotFoundException,
ImageNotSupportedException, DatabaseConnectionException, QueryNotFoundException, QueryStoreException, UserNotFoundException;
/**
* Inserts a query and metadata to the query store of a given database id
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param metadata The statement.
* @param principal The user principal.
@@ -56,18 +51,15 @@ public interface StoreService {
* @throws QueryStoreException The query store raised some error
* @throws DatabaseNotFoundException The database id was not found in the metadata database
* @throws ImageNotSupportedException The image is not supported
- * @throws ContainerNotFoundException The container was not found in the metadata database.
* @throws UserNotFoundException The user was not found in the metadata database.
* @throws DatabaseConnectionException The database connection to the remote container failed.
*/
- Query insert(Long containerId, Long databaseId, ExecuteStatementDto metadata, Principal principal) throws QueryStoreException,
- DatabaseNotFoundException, ImageNotSupportedException, ContainerNotFoundException, UserNotFoundException,
- DatabaseConnectionException;
+ Query insert(Long databaseId, ExecuteStatementDto metadata, Principal principal) throws QueryStoreException,
+ DatabaseNotFoundException, ImageNotSupportedException, UserNotFoundException, DatabaseConnectionException;
/**
* Persists a query to be displayed in the frontend
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param queryId The query id.
* @param principal The user principal.
@@ -77,7 +69,7 @@ public interface StoreService {
* @throws DatabaseConnectionException The database connection to the remote container failed.
* @throws QueryStoreException The query store raised some error.
*/
- Query persist(Long containerId, Long databaseId, Long queryId, Principal principal) throws DatabaseNotFoundException,
+ Query persist(Long databaseId, Long queryId, Principal principal) throws DatabaseNotFoundException,
ImageNotSupportedException, DatabaseConnectionException, QueryStoreException, UserNotFoundException;
/**
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/TableService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/TableService.java
index a6d4ff28b917bdd08ac5c0d3e25a1a927552dbf5..699260696e63256ddc9c15f7b3f640c48d6638b0 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/TableService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/TableService.java
@@ -3,7 +3,6 @@ package at.tuwien.service;
import at.tuwien.api.database.table.TableHistoryDto;
import at.tuwien.entities.database.table.Table;
import at.tuwien.exception.*;
-import org.springframework.transaction.annotation.Transactional;
import java.security.Principal;
import java.util.List;
@@ -13,14 +12,13 @@ public interface TableService {
/**
* Find a table in the metadata database by database-table id tuple
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @return The database.
* @throws DatabaseNotFoundException The database is not found.
* @throws TableNotFoundException The table is not found.
*/
- Table find(Long containerId, Long databaseId, Long tableId) throws DatabaseNotFoundException, TableNotFoundException;
+ Table find(Long databaseId, Long tableId) throws DatabaseNotFoundException, TableNotFoundException;
/**
* Finds all tables in the metdata database.
@@ -32,7 +30,6 @@ public interface TableService {
/**
* Find the table history.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param tableId The table id.
* @param principal The user principal.
@@ -41,6 +38,6 @@ public interface TableService {
* @throws DatabaseNotFoundException The database is not found.
* @throws TableNotFoundException The table is not found.
*/
- List<TableHistoryDto> findHistory(Long containerId, Long databaseId, Long tableId, Principal principal)
+ List<TableHistoryDto> findHistory(Long databaseId, Long tableId, Principal principal)
throws DatabaseNotFoundException, QueryMalformedException, TableNotFoundException, DatabaseConnectionException, QueryStoreException, UserNotFoundException;
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/ViewService.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/ViewService.java
index e5d188260872b8ddfda261b26b4e7f2faf1460c2..be7e631bdf1c023f00bdc8221e6bdd5121283ac0 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/ViewService.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/ViewService.java
@@ -34,7 +34,6 @@ public interface ViewService {
/**
* Delete view in the container with the given id and database with id and the given view id.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param id The view id.
* @param principal The authorization principal.
@@ -45,13 +44,12 @@ public interface ViewService {
* @throws QueryMalformedException The query to delete the view is malformed.
* @throws ViewMalformedException The view is malformed and could not be deleted.
*/
- void delete(Long containerId, Long databaseId, Long id, Principal principal) throws ViewNotFoundException,
+ void delete(Long databaseId, Long id, Principal principal) throws ViewNotFoundException,
UserNotFoundException, DatabaseNotFoundException, DatabaseConnectionException, QueryMalformedException, ViewMalformedException;
/**
* Creates a view in the container with given id and database with id with the given query.
*
- * @param containerId The container id.
* @param databaseId The database id.
* @param data The given query.
* @param principal The authorization principal.
@@ -62,6 +60,6 @@ public interface ViewService {
* @throws ViewMalformedException The view is malformed and could not be created.
* @throws UserNotFoundException The user with authorization principal was not found.
*/
- View create(Long containerId, Long databaseId, ViewCreateDto data, Principal principal) throws DatabaseNotFoundException,
+ View create(Long databaseId, ViewCreateDto data, Principal principal) throws DatabaseNotFoundException,
DatabaseConnectionException, QueryMalformedException, ViewMalformedException, UserNotFoundException;
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceImpl.java
index 4a2a8927f76e589c747a6238c5db232533b7f665..80d6ce2c6458e8e4d76fcf94331679dbb298201d 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceImpl.java
@@ -25,10 +25,10 @@ public class DatabaseServiceImpl implements DatabaseService {
@Override
@Transactional(readOnly = true)
- public Database find(Long containerId, Long databaseId) throws DatabaseNotFoundException {
- final Optional<Database> database = databaseRepository.findByContainerIdAndDatabaseId(containerId, databaseId);
+ public Database find(Long databaseId) throws DatabaseNotFoundException {
+ final Optional<Database> database = databaseRepository.findByDatabaseId(databaseId);
if (database.isEmpty()) {
- log.error("Failed to find database with container id {} and database id {}", containerId, databaseId);
+ log.error("Failed to find database with database id {}", databaseId);
throw new DatabaseNotFoundException("Failed to find database");
}
return database.get();
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java
index 1ed1d00e1a93804071d4cf0bbc9ba7fb3d399b8d..f17bbadccdcbeb024a20b4cb6a78aca84c63736a 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java
@@ -2,31 +2,21 @@ package at.tuwien.service.impl;
import at.tuwien.entities.container.Container;
import at.tuwien.entities.container.image.ContainerImage;
-import at.tuwien.entities.container.image.ContainerImageEnvironmentItem;
-import at.tuwien.entities.container.image.ContainerImageEnvironmentItemType;
import at.tuwien.entities.database.Database;
-import at.tuwien.entities.user.User;
-import at.tuwien.exception.DatabaseConnectionException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
-import java.security.Principal;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.stream.Collectors;
-
@Log4j2
@Service
public abstract class HibernateConnector {
- protected static ComboPooledDataSource getDataSource(ContainerImage image, Container container, Database database,
- User user) {
+ protected static ComboPooledDataSource getPrivilegedDataSource(ContainerImage image, Container container, Database database) {
final ComboPooledDataSource dataSource = new ComboPooledDataSource();
- final String url = "jdbc:" + image.getJdbcMethod() + "://" + container.getInternalName() + "/" + (database != null ? database.getInternalName() : "");
+ final String url = "jdbc:" + image.getJdbcMethod() + "://" + container.getHost() + ":" + container.getPort() + "/" + (database != null ? database.getInternalName() : "");
dataSource.setJdbcUrl(url);
- dataSource.setUser(user.getUsername());
- dataSource.setPassword(user.getDatabasePassword());
+ dataSource.setUser(container.getPrivilegedUsername());
+ dataSource.setPassword(container.getPrivilegedPassword());
dataSource.setInitialPoolSize(5);
dataSource.setMinPoolSize(5);
dataSource.setAcquireIncrement(5);
@@ -35,5 +25,4 @@ public abstract class HibernateConnector {
log.trace("created pooled data source {}", dataSource);
return dataSource;
}
-
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/QueryServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/QueryServiceImpl.java
index b230ecadb520d8e9dd75f8e4a034fefbdaa516b0..386a2cf574922277ca1c67851c04f7d5ed2fbe7a 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/QueryServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/QueryServiceImpl.java
@@ -12,12 +12,13 @@ import at.tuwien.entities.database.Database;
import at.tuwien.entities.database.View;
import at.tuwien.entities.database.table.Table;
import at.tuwien.entities.database.table.columns.TableColumn;
-import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
-import at.tuwien.mapper.DatabaseMapper;
import at.tuwien.mapper.QueryMapper;
import at.tuwien.querystore.Query;
-import at.tuwien.service.*;
+import at.tuwien.service.DatabaseService;
+import at.tuwien.service.QueryService;
+import at.tuwien.service.StoreService;
+import at.tuwien.service.TableService;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import lombok.extern.log4j.Log4j2;
import net.sf.jsqlparser.JSQLParserException;
@@ -54,43 +55,41 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
private final QueryMapper queryMapper;
private final TableService tableService;
private final StoreService storeService;
- private final DatabaseMapper databaseMapper;
private final DatabaseService databaseService;
@Autowired
public QueryServiceImpl(QueryMapper queryMapper, TableService tableService,
- DatabaseService databaseService, StoreService storeService, DatabaseMapper databaseMapper) {
+ DatabaseService databaseService, StoreService storeService) {
this.queryMapper = queryMapper;
this.tableService = tableService;
this.storeService = storeService;
- this.databaseMapper = databaseMapper;
this.databaseService = databaseService;
}
@Override
@Transactional(readOnly = true)
- public QueryResultDto execute(Long containerId, Long databaseId, ExecuteStatementDto statement,
+ public QueryResultDto execute(Long databaseId, ExecuteStatementDto statement,
Principal principal, Long page, Long size, SortType sortDirection, String sortColumn)
throws DatabaseNotFoundException, ImageNotSupportedException, QueryMalformedException, QueryStoreException,
- ContainerNotFoundException, ColumnParseException, UserNotFoundException, DatabaseConnectionException,
+ ColumnParseException, UserNotFoundException, DatabaseConnectionException,
TableMalformedException {
if (statement.getStatement().contains(";")) {
log.error("Failed to execute query since it contains ';'");
throw new QueryMalformedException("Failed to execute query since it contains ';'");
}
- final Query query = storeService.insert(containerId, databaseId, statement, principal);
- return reExecute(containerId, databaseId, query, page, size, sortDirection, sortColumn, principal);
+ final Query query = storeService.insert(databaseId, statement, principal);
+ return reExecute(databaseId, query, page, size, sortDirection, sortColumn, principal);
}
@Override
@Transactional(readOnly = true)
- public QueryResultDto reExecute(Long containerId, Long databaseId, Query query, Long page, Long size,
+ public QueryResultDto reExecute(Long databaseId, Query query, Long page, Long size,
SortType sortDirection, String sortColumn, Principal principal)
throws QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ColumnParseException,
TableMalformedException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
/* map the result to the tables (with respective columns) from the statement metadata */
@@ -102,7 +101,7 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
throw new ColumnParseException("Failed to map/parse columns: " + e.getMessage(), e);
}
final String statement = queryMapper.queryToRawTimestampedQuery(query.getQuery(), database, query.getCreated(), true, page, size);
- final QueryResultDto dto = executeNonPersistent(containerId, databaseId, statement, columns);
+ final QueryResultDto dto = executeNonPersistent(databaseId, statement, columns);
dto.setId(query.getId());
dto.setResultNumber(query.getResultNumber());
return dto;
@@ -110,12 +109,12 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional(readOnly = true)
- public Long reExecuteCount(Long containerId, Long databaseId, Query query, Principal principal)
+ public Long reExecuteCount(Long databaseId, Query query, Principal principal)
throws QueryMalformedException, DatabaseNotFoundException, ImageNotSupportedException, ColumnParseException,
TableMalformedException, QueryStoreException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
/* run query */
@@ -126,7 +125,7 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
throw new ColumnParseException("Failed to map/parse columns: " + e.getMessage(), e);
}
final String statement = queryMapper.queryToRawTimestampedQuery(query.getQuery(), database, query.getCreated(), false, null, null);
- return executeCountNonPersistent(containerId, databaseId, statement);
+ return executeCountNonPersistent(databaseId, statement);
}
private PreparedStatement prepareStatement(Connection connection, String statement) throws QueryMalformedException {
@@ -138,14 +137,13 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
}
}
- private QueryResultDto executeNonPersistent(Long containerId, Long databaseId, String statement, List<TableColumn> columns)
+ private QueryResultDto executeNonPersistent(Long databaseId, String statement, List<TableColumn> columns)
throws QueryMalformedException, DatabaseNotFoundException, TableMalformedException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
try {
final Connection connection = dataSource.getConnection();
final PreparedStatement preparedStatement = prepareStatement(connection, statement);
@@ -159,14 +157,13 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
}
}
- private Long executeCountNonPersistent(Long containerId, Long databaseId, String statement)
+ private Long executeCountNonPersistent(Long databaseId, String statement)
throws QueryMalformedException, TableMalformedException, DatabaseNotFoundException, QueryStoreException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
try {
final Connection connection = dataSource.getConnection();
final PreparedStatement preparedStatement = prepareStatement(connection, statement);
@@ -182,71 +179,70 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional(readOnly = true)
- public QueryResultDto tableFindAll(Long containerId, Long databaseId, Long tableId, Instant timestamp, Long page,
+ public QueryResultDto tableFindAll(Long databaseId, Long tableId, Instant timestamp, Long page,
Long size, Principal principal) throws TableNotFoundException, DatabaseNotFoundException,
ImageNotSupportedException, TableMalformedException, QueryMalformedException {
/* find */
- final Table table = tableService.find(containerId, databaseId, tableId);
+ final Table table = tableService.find(databaseId, tableId);
/* run query */
String statement = queryMapper.tableToRawFindAllQuery(table, timestamp, size, page);
- return executeNonPersistent(containerId, databaseId, statement, table.getColumns());
+ return executeNonPersistent(databaseId, statement, table.getColumns());
}
@Override
@Transactional(readOnly = true)
- public QueryResultDto viewFindAll(Long containerId, Long databaseId, View view,
+ public QueryResultDto viewFindAll(Long databaseId, View view,
Long page, Long size, Principal principal) throws DatabaseNotFoundException,
ImageNotSupportedException, QueryMalformedException, TableMalformedException {
/* find */
/* run query */
String statement = queryMapper.viewToRawFindAllQuery(view, size, page);
- return executeNonPersistent(containerId, databaseId, statement, view.getColumns());
+ return executeNonPersistent(databaseId, statement, view.getColumns());
}
@Override
@Transactional
- public Long tableCount(Long containerId, Long databaseId, Long tableId, Instant timestamp, Principal principal)
+ public Long tableCount(Long databaseId, Long tableId, Instant timestamp, Principal principal)
throws DatabaseNotFoundException, TableNotFoundException, ImageNotSupportedException,
QueryMalformedException, QueryStoreException, TableMalformedException {
/* find */
- final Table table = tableService.find(containerId, databaseId, tableId);
+ final Table table = tableService.find(databaseId, tableId);
final String statement = queryMapper.tableToRawCountAllQuery(table, timestamp);
- return executeCountNonPersistent(containerId, databaseId, statement);
+ return executeCountNonPersistent(databaseId, statement);
}
@Override
@Transactional
- public Long viewCount(Long containerId, Long databaseId, View view, Principal principal)
+ public Long viewCount(Long databaseId, View view, Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException,
QueryMalformedException, QueryStoreException, TableMalformedException {
/* find */
final String statement = queryMapper.viewToRawCountAllQuery(view);
- return executeCountNonPersistent(containerId, databaseId, statement);
+ return executeCountNonPersistent(databaseId, statement);
}
@Transactional(readOnly = true)
- public QueryResultDto findAllView(Long containerId, Long databaseId, Long viewId, Instant timestamp, Long page,
+ public QueryResultDto findAllView(Long databaseId, Long viewId, Instant timestamp, Long page,
Long size, Principal principal) throws TableNotFoundException, DatabaseNotFoundException,
ImageNotSupportedException, TableMalformedException, QueryMalformedException {
/* find */
- final Table table = tableService.find(containerId, databaseId, viewId);
+ final Table table = tableService.find(databaseId, viewId);
/* run query */
String statement = queryMapper.tableToRawFindAllQuery(table, timestamp, size, page);
- return executeNonPersistent(containerId, databaseId, statement, table.getColumns());
+ return executeNonPersistent(databaseId, statement, table.getColumns());
}
@Override
@Transactional(readOnly = true)
- public ExportResource tableFindAll(Long containerId, Long databaseId, Long tableId, Instant timestamp, Principal principal)
+ public ExportResource tableFindAll(Long databaseId, Long tableId, Instant timestamp, Principal principal)
throws TableNotFoundException, DatabaseNotFoundException, FileStorageException, QueryMalformedException {
final String filename = RandomStringUtils.randomAlphabetic(40) + ".csv";
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = tableService.find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = tableService.find(databaseId, tableId);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* read file */
final InputStreamResource resource;
try {
@@ -270,17 +266,16 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional(readOnly = true)
- public ExportResource findOne(Long containerId, Long databaseId, Long queryId, Principal principal)
+ public ExportResource findOne(Long databaseId, Long queryId, Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException, FileStorageException, QueryStoreException,
QueryNotFoundException, QueryMalformedException, DatabaseConnectionException, UserNotFoundException {
final String filename = RandomStringUtils.randomAlphabetic(40) + ".csv";
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Query query = storeService.findOne(containerId, databaseId, queryId, principal);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Query query = storeService.findOne(databaseId, queryId, principal);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* read file */
final InputStreamResource resource;
try {
@@ -309,17 +304,16 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional
- public void update(Long containerId, Long databaseId, Long tableId, TableCsvUpdateDto data, Principal principal)
+ public void update(Long databaseId, Long tableId, TableCsvUpdateDto data, Principal principal)
throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
TableNotFoundException, QueryMalformedException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = tableService.find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = tableService.find(databaseId, tableId);
/* run query */
if (data.getData().size() == 0 || data.getKeys().size() == 0) return;
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
try {
final Connection connection = dataSource.getConnection();
final PreparedStatement preparedStatement = queryMapper.tableCsvDtoToRawUpdateQuery(connection, table, data);
@@ -334,17 +328,15 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional
- public void insert(Long containerId, Long databaseId, Long tableId, TableCsvDto data, Principal principal)
- throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
- TableNotFoundException, ContainerNotFoundException, DatabaseConnectionException, UserNotFoundException {
+ public void insert(Long databaseId, Long tableId, TableCsvDto data, Principal principal)
+ throws TableMalformedException, DatabaseNotFoundException, TableNotFoundException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = tableService.find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = tableService.find(databaseId, tableId);
log.trace("parsed insert data {}", data);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* prepare the statement */
try {
final Connection connection = dataSource.getConnection();
@@ -366,17 +358,16 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional
- public void delete(Long containerId, Long databaseId, Long tableId, TableCsvDeleteDto data, Principal principal)
+ public void delete(Long databaseId, Long tableId, TableCsvDeleteDto data, Principal principal)
throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
TableNotFoundException, DatabaseConnectionException, QueryMalformedException, UserNotFoundException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = tableService.find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = tableService.find(databaseId, tableId);
/* run query */
if (data.getKeys().size() == 0) return;
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* prepare the statement */
try {
final Connection connection = dataSource.getConnection();
@@ -392,17 +383,14 @@ public class QueryServiceImpl extends HibernateConnector implements QueryService
@Override
@Transactional
- public void insert(Long containerId, Long databaseId, Long tableId, ImportDto data, Principal principal)
- throws ImageNotSupportedException, TableMalformedException, DatabaseNotFoundException,
- TableNotFoundException, ContainerNotFoundException, DatabaseConnectionException, QueryMalformedException,
- UserNotFoundException {
+ public void insert(Long databaseId, Long tableId, ImportDto data, Principal principal)
+ throws TableMalformedException, DatabaseNotFoundException, TableNotFoundException, QueryMalformedException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = tableService.find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = tableService.find(databaseId, tableId);
/* preparing the statements */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* Create a temporary table, insert there, transfer with update on duplicate key and lastly drops the temporary table */
try {
final Connection connection = dataSource.getConnection();
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/RabbitMqServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/RabbitMqServiceImpl.java
index e814476f1d0032afd82b0fc8d6bf48df1581f788..f6f3b647f8bc0a2c63bdabc756c13eb76fd23d08 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/RabbitMqServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/RabbitMqServiceImpl.java
@@ -4,13 +4,14 @@ import at.tuwien.amqp.RabbitMqConsumer;
import at.tuwien.api.amqp.ConsumerDto;
import at.tuwien.config.AmqpConfig;
import at.tuwien.entities.database.table.Table;
-import at.tuwien.exception.*;
+import at.tuwien.exception.AmqpException;
import at.tuwien.gateway.BrokerServiceGateway;
import at.tuwien.service.MessageQueueService;
import at.tuwien.service.QueryService;
import at.tuwien.service.TableService;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.rabbitmq.client.*;
+import com.rabbitmq.client.Channel;
+import com.rabbitmq.client.Connection;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -42,7 +43,7 @@ public class RabbitMqServiceImpl implements MessageQueueService {
}
@Override
- public void createConsumer(String queueName, Long containerId, Long databaseId, Long tableId) throws AmqpException {
+ public void createConsumer(String queueName, Long databaseId, Long tableId) throws AmqpException {
try {
if (!this.channel.isOpen()) {
log.warn("Channel with id {} is closed", this.channel.getChannelNumber());
@@ -50,8 +51,7 @@ public class RabbitMqServiceImpl implements MessageQueueService {
this.channel = tmp.createChannel();
log.info("Opened channel with id {}", this.channel.getChannelNumber());
}
- final String consumerTag = this.channel.basicConsume(queueName, true, new RabbitMqConsumer(containerId,
- databaseId, tableId, objectMapper, queryService));
+ final String consumerTag = this.channel.basicConsume(queueName, true, new RabbitMqConsumer(databaseId, tableId, objectMapper, queryService));
log.debug("declared consumer for queue name {} with tag {}", queueName, consumerTag);
} catch (IOException e) {
log.error("Failed to create consumer for table with id {}, reason: {}", tableId, e.getMessage());
@@ -72,8 +72,7 @@ public class RabbitMqServiceImpl implements MessageQueueService {
continue;
}
for (long i = consumerCount; i < amqpConfig.getAmqpConsumers(); i++) {
- createConsumer(table.getQueueName(), table.getDatabase().getContainer().getId(),
- table.getDatabase().getId(), table.getId());
+ createConsumer(table.getQueueName(), table.getDatabase().getId(), table.getId());
}
}
}
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/StoreServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/StoreServiceImpl.java
index 4bfb01e9d4f440c041e36c195e8387edbefa1458..bacc9cff596269628259016ec45568a16283018a 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/StoreServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/StoreServiceImpl.java
@@ -1,10 +1,9 @@
package at.tuwien.service.impl;
import at.tuwien.api.database.query.ExecuteStatementDto;
-import at.tuwien.entities.user.User;
import at.tuwien.entities.database.Database;
+import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
-import at.tuwien.mapper.DatabaseMapper;
import at.tuwien.mapper.StoreMapper;
import at.tuwien.querystore.Query;
import at.tuwien.service.DatabaseService;
@@ -27,33 +26,29 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
private final StoreMapper storeMapper;
private final UserService userService;
- private final DatabaseMapper databaseMapper;
private final DatabaseService databaseService;
@Autowired
- public StoreServiceImpl(StoreMapper storeMapper, UserService userService, DatabaseMapper databaseMapper,
- DatabaseService databaseService) {
+ public StoreServiceImpl(StoreMapper storeMapper, UserService userService, DatabaseService databaseService) {
this.storeMapper = storeMapper;
this.userService = userService;
- this.databaseMapper = databaseMapper;
this.databaseService = databaseService;
}
@Override
@Transactional(readOnly = true)
- public List<Query> findAll(Long containerId, Long databaseId, Boolean persisted, Principal principal)
+ public List<Query> findAll(Long databaseId, Boolean persisted, Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException, QueryStoreException,
ContainerNotFoundException, DatabaseConnectionException, TableMalformedException, UserNotFoundException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* select all */
try {
final Connection connection = dataSource.getConnection();
@@ -61,7 +56,7 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
final ResultSet resultSet = preparedStatement.executeQuery();
return resultSetToQueryList(resultSet);
} catch (SQLException e) {
- log.error("Failed to find queries in container with id {} and database with id {}, reason: {}", containerId, databaseId, e.getMessage());
+ log.error("Failed to find queries in container with database with id {}, reason: {}", databaseId, e.getMessage());
throw new QueryStoreException("Failed to find queries: " + e.getMessage());
} finally {
dataSource.close();
@@ -70,17 +65,16 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
@Override
@Transactional(readOnly = true)
- public Query findOne(Long containerId, Long databaseId, Long queryId, Principal principal)
+ public Query findOne(Long databaseId, Long queryId, Principal principal)
throws DatabaseNotFoundException, ImageNotSupportedException, QueryNotFoundException, QueryStoreException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* use jpa to select one */
try {
final Connection connection = dataSource.getConnection();
@@ -101,18 +95,17 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
@Override
@Transactional(readOnly = true)
- public Query insert(Long containerId, Long databaseId, ExecuteStatementDto metadata, Principal principal)
+ public Query insert(Long databaseId, ExecuteStatementDto metadata, Principal principal)
throws QueryStoreException, DatabaseNotFoundException, ImageNotSupportedException,
- ContainerNotFoundException, UserNotFoundException, DatabaseConnectionException {
+ UserNotFoundException, DatabaseConnectionException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
log.trace("insert into database id {}, metadata {}", databaseId, metadata);
/* user */
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
final User creator;
if (principal != null) {
creator = userService.findByUsername(principal.getName());
@@ -120,8 +113,8 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
creator = userService.findByUsername("system");
}
/* save */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
try {
final Connection connection = dataSource.getConnection();
final CallableStatement callableStatement = storeMapper.queryStoreRawInsertQuery(connection, creator, metadata);
@@ -148,18 +141,17 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
@Override
@Transactional
- public Query persist(Long containerId, Long databaseId, Long queryId, Principal principal)
- throws DatabaseNotFoundException, ImageNotSupportedException, QueryStoreException, UserNotFoundException {
+ public Query persist(Long databaseId, Long queryId, Principal principal)
+ throws DatabaseNotFoundException, ImageNotSupportedException, QueryStoreException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ final Database database = databaseService.find(databaseId);
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
/* persist */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
final Query out;
try {
final Connection connection = dataSource.getConnection();
@@ -186,14 +178,13 @@ public class StoreServiceImpl extends HibernateConnector implements StoreService
/* find */
final List<Database> databases = databaseService.findAll();
for (Database database : databases) {
- if (!database.getContainer().getImage().getRepository().equals("mariadb")) {
+ if (!database.getContainer().getImage().getName().equals("mariadb")) {
log.error("Currently only MariaDB is supported");
throw new ImageNotSupportedException("Currently only MariaDB is supported");
}
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* delete stale queries older than 24hrs */
try {
final Connection connection = dataSource.getConnection();
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/TableServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/TableServiceImpl.java
index 0ad279d9daa34122e068cfd0cca4f11e53f80e7a..6961541e012edc529a667c595ac33e820df8db4f 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/TableServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/TableServiceImpl.java
@@ -3,9 +3,10 @@ package at.tuwien.service.impl;
import at.tuwien.api.database.table.TableHistoryDto;
import at.tuwien.entities.database.Database;
import at.tuwien.entities.database.table.Table;
-import at.tuwien.entities.user.User;
-import at.tuwien.exception.*;
-import at.tuwien.mapper.DatabaseMapper;
+import at.tuwien.exception.DatabaseNotFoundException;
+import at.tuwien.exception.QueryMalformedException;
+import at.tuwien.exception.QueryStoreException;
+import at.tuwien.exception.TableNotFoundException;
import at.tuwien.mapper.QueryMapper;
import at.tuwien.repository.mdb.TableRepository;
import at.tuwien.service.DatabaseService;
@@ -21,31 +22,29 @@ import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
-import java.util.*;
+import java.util.List;
+import java.util.Optional;
@Log4j2
@Service
public class TableServiceImpl extends HibernateConnector implements TableService {
private final QueryMapper queryMapper;
- private final DatabaseMapper databaseMapper;
private final TableRepository tableRepository;
private final DatabaseService databaseService;
@Autowired
- public TableServiceImpl(QueryMapper queryMapper, DatabaseMapper databaseMapper, TableRepository tableRepository,
- DatabaseService databaseService) {
+ public TableServiceImpl(QueryMapper queryMapper, TableRepository tableRepository, DatabaseService databaseService) {
this.queryMapper = queryMapper;
- this.databaseMapper = databaseMapper;
this.tableRepository = tableRepository;
this.databaseService = databaseService;
}
@Override
@Transactional(readOnly = true)
- public Table find(Long containerId, Long databaseId, Long tableId) throws DatabaseNotFoundException,
+ public Table find(Long databaseId, Long tableId) throws DatabaseNotFoundException,
TableNotFoundException {
- final Optional<Table> table = tableRepository.find(containerId, databaseId, tableId);
+ final Optional<Table> table = tableRepository.find(databaseId, tableId);
if (table.isEmpty()) {
log.error("Failed to find table with id {} in database with id {}", tableId, databaseId);
throw new TableNotFoundException("Failed to find table");
@@ -61,15 +60,14 @@ public class TableServiceImpl extends HibernateConnector implements TableService
@Override
@Transactional(readOnly = true)
- public List<TableHistoryDto> findHistory(Long containerId, Long databaseId, Long tableId, Principal principal)
+ public List<TableHistoryDto> findHistory(Long databaseId, Long tableId, Principal principal)
throws DatabaseNotFoundException, TableNotFoundException, QueryStoreException, QueryMalformedException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
- final Table table = find(containerId, databaseId, tableId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
+ final Table table = find(databaseId, tableId);
/* run query */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
/* use jpa to select one */
try {
final Connection connection = dataSource.getConnection();
diff --git a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/ViewServiceImpl.java b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/ViewServiceImpl.java
index e259d39c46b253a94107caa3fb836bd766ce1f7b..b1605f80db2eb2f3292aeda82776202908900eca 100644
--- a/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/ViewServiceImpl.java
+++ b/dbrepo-query-service/services/src/main/java/at/tuwien/service/impl/ViewServiceImpl.java
@@ -6,7 +6,6 @@ import at.tuwien.entities.database.View;
import at.tuwien.entities.database.table.columns.TableColumn;
import at.tuwien.entities.user.User;
import at.tuwien.exception.*;
-import at.tuwien.mapper.DatabaseMapper;
import at.tuwien.mapper.ViewMapper;
import at.tuwien.repository.sdb.ViewIdxRepository;
import at.tuwien.repository.mdb.ViewRepository;
@@ -34,19 +33,16 @@ public class ViewServiceImpl extends HibernateConnector implements ViewService {
private final ViewMapper viewMapper;
private final UserService userService;
- private final DatabaseMapper databaseMapper;
private final ViewRepository viewRepository;
private final DatabaseService databaseService;
private final ViewIdxRepository viewIdxRepository;
private final QueryService queryService;
@Autowired
- public ViewServiceImpl(ViewMapper viewMapper, UserService userService, DatabaseMapper databaseMapper,
- ViewRepository viewRepository, DatabaseService databaseService,
- ViewIdxRepository viewIdxRepository, QueryService queryService) {
+ public ViewServiceImpl(ViewMapper viewMapper, UserService userService, ViewRepository viewRepository,
+ DatabaseService databaseService, ViewIdxRepository viewIdxRepository, QueryService queryService) {
this.viewMapper = viewMapper;
this.userService = userService;
- this.databaseMapper = databaseMapper;
this.viewRepository = viewRepository;
this.databaseService = databaseService;
this.viewIdxRepository = viewIdxRepository;
@@ -84,15 +80,14 @@ public class ViewServiceImpl extends HibernateConnector implements ViewService {
@Override
@Transactional
- public void delete(Long containerId, Long databaseId, Long id, Principal principal) throws ViewNotFoundException,
+ public void delete(Long databaseId, Long id, Principal principal) throws ViewNotFoundException,
UserNotFoundException, DatabaseNotFoundException, DatabaseConnectionException, QueryMalformedException, ViewMalformedException {
/* find */
final View view = findById(databaseId, id, principal);
- final Database database = databaseService.find(containerId, databaseId);
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
+ final Database database = databaseService.find(databaseId);
/* delete view */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
try {
final Connection connection = dataSource.getConnection();
final PreparedStatement createViewStatement = viewMapper.viewToRawDeleteViewQuery(connection, view);
@@ -112,16 +107,15 @@ public class ViewServiceImpl extends HibernateConnector implements ViewService {
@Override
@Transactional
- public View create(Long containerId, Long databaseId, ViewCreateDto data, Principal principal)
+ public View create(Long databaseId, ViewCreateDto data, Principal principal)
throws DatabaseNotFoundException, DatabaseConnectionException, QueryMalformedException,
ViewMalformedException, UserNotFoundException {
/* find */
- final Database database = databaseService.find(containerId, databaseId);
+ final Database database = databaseService.find(databaseId);
final User user = userService.findByUsername(principal.getName());
- final User root = databaseMapper.containerToPrivilegedUser(database.getContainer());
/* create view */
- final ComboPooledDataSource dataSource = getDataSource(database.getContainer().getImage(),
- database.getContainer(), database, root);
+ final ComboPooledDataSource dataSource = getPrivilegedDataSource(database.getContainer().getImage(),
+ database.getContainer(), database);
final List<TableColumn> columns;
try {
columns = queryService.parseColumns(data.getQuery(), database);
@@ -141,7 +135,6 @@ public class ViewServiceImpl extends HibernateConnector implements ViewService {
}
/* save in metadata database */
final View entity = View.builder()
- .vcid(containerId)
.vdbid(databaseId)
.name(data.getName())
.internalName(viewMapper.nameToInternalName(data.getName()))
diff --git a/dbrepo-query-service/services/src/test/resources/application.properties b/dbrepo-query-service/services/src/test/resources/application.properties
deleted file mode 100644
index b314af67d812d79f89da0e35e1c49f1d9380f04f..0000000000000000000000000000000000000000
--- a/dbrepo-query-service/services/src/test/resources/application.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-# disable discovery
-spring.cloud.discovery.enabled = false
-
-# disable cloud config and config discovery
-spring.cloud.config.discovery.enabled = false
-spring.cloud.config.enabled = false
-
-# disable datasource
-spring.datasource.url=jdbc:h2:mem:testdb
-spring.datasource.driverClassName=org.h2.Driver
-spring.datasource.username=sa
-spring.datasource.password=password
-spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
-spring.jpa.hibernate.ddl-auto=update
-
-# rabbitmq
-spring.rabbitmq.host=dbrepo-broker-service
-spring.rabbitmq.virtual-host=/
-spring.rabbitmq.username=guest
-spring.rabbitmq.password=guest
\ No newline at end of file