From 496978ad257957545e3dfe1288843f6ea1248ffe Mon Sep 17 00:00:00 2001 From: Mariusz Wyszomierski Date: Thu, 28 Jun 2018 23:08:55 +0200 Subject: [PATCH] Add feature to create template in PostgreSQL Main change in GeneralTemplateGatewayImpl. Add configuration and description how to run it local. --- cascades-server/README.md | 9 + cascades-server/app/pom.xml | 13 ++ .../application-production.properties | 8 + .../server/ConnectionConfiguration.java | 4 +- .../server/ConnectionConfigurator.java | 22 +-- .../server/DatabaseEndpointConfiguration.java | 42 ++-- .../server/DatabaseEndpointManager.java | 17 +- .../coi/cascades/server/DatabaseManager.java | 15 +- .../server/DriverManagerDataSourceHelper.java | 83 ++++++++ .../DriverManagerDataSourceProvider.java | 15 ++ .../DriverManagerDataSourceProviderImpl.java | 14 ++ .../server/GeneralTemplateGateway.java | 82 ++++---- .../pl/gov/coi/cascades/server/ServerDef.java | 25 ++- .../hibernate/HibernateConfiguration.java | 15 ++ .../server/ConnectionConfigurationTest.java | 4 +- .../server/ConnectionConfiguratorTest.java | 80 ++------ .../DatabaseEndpointConfigurationTest.java | 71 ++++--- .../server/DatabaseEndpointManagerTest.java | 46 +++-- .../DriverManagerDataSourceHelperTest.java | 129 ++++++++++++ ...iverManagerDataSourceProviderImplTest.java | 20 ++ .../server/GeneralTemplateGatewayTest.java | 185 ++++++++++++++++++ .../coi/cascades/server/ServerDefTest.java | 66 ++++--- .../hibernate/HibernateConfigurationTest.java | 43 ++-- .../src/test/resources/deploy.sql | 1 + .../DatabaseInstanceGatewayImpl.java | 51 +++++ .../hibernate/DatabaseLimitGatewayImpl.java | 54 +++++ .../DatabaseInstanceGatewayImplTest.java | 40 ++++ .../DatabaseLimitGatewayImplTest.java | 64 ++++++ 28 files changed, 999 insertions(+), 219 deletions(-) create mode 100644 cascades-server/README.md create mode 100644 cascades-server/app/src/main/resources/application-production.properties create mode 100644 cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelper.java create mode 100644 cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProvider.java create mode 100644 cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImpl.java create mode 100644 cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelperTest.java create mode 100644 cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImplTest.java create mode 100644 cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/GeneralTemplateGatewayTest.java create mode 100644 cascades-server/configuration/src/test/resources/deploy.sql create mode 100644 cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImpl.java create mode 100644 cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImpl.java create mode 100644 cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImplTest.java create mode 100644 cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImplTest.java diff --git a/cascades-server/README.md b/cascades-server/README.md new file mode 100644 index 0000000..ab5b024 --- /dev/null +++ b/cascades-server/README.md @@ -0,0 +1,9 @@ +# Example usage + +* Run PostgreSQL server in docker +`docker run --name cascades-postgres -e POSTGRES_PASSWORD=mysecretpassword -d -p 5432:5432 postgres:10.4` + +* Build project with profile `-Ppostgresql` +It adds PostgreSQL driver. + +* Run application with profile `mvn spring-boot:run --Dspring.profiles.activeproduction,hibernate,postgresqldocker` diff --git a/cascades-server/app/pom.xml b/cascades-server/app/pom.xml index 407c666..c33cce6 100644 --- a/cascades-server/app/pom.xml +++ b/cascades-server/app/pom.xml @@ -98,4 +98,17 @@ + + + postgresql + + + postgresql + postgresql + 9.0-801.jdbc4 + + + + + diff --git a/cascades-server/app/src/main/resources/application-production.properties b/cascades-server/app/src/main/resources/application-production.properties new file mode 100644 index 0000000..459fb1f --- /dev/null +++ b/cascades-server/app/src/main/resources/application-production.properties @@ -0,0 +1,8 @@ +# run PostgreSQL in docker: docker run --name cascades-postgres -e POSTGRES_PASSWORD=mysecretpassword -d -p 5432:5432 postgres:10.4 +cascades.managedServers[0].serverId=testdb +cascades.managedServers[0].type=pgsql +cascades.managedServers[0].dbname=postgres +cascades.managedServers[0].user=postgres +cascades.managedServers[0].password=mysecretpassword +cascades.managedServers[0].host=localhost +cascades.managedServers[0].port=5432 diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfiguration.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfiguration.java index 7cd08bc..5dab936 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfiguration.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfiguration.java @@ -12,6 +12,6 @@ @AllArgsConstructor @RequiredArgsConstructor class ConnectionConfiguration { - private String driver; - private String url; + private String driverClass; + private String jdbcUrlTemplate; } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfigurator.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfigurator.java index 605662d..ad89ff2 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfigurator.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ConnectionConfigurator.java @@ -8,27 +8,27 @@ */ public class ConnectionConfigurator { - ConnectionConfiguration getConnectionConfiguration(ServerDef serverDef) { - String driver; - String url; - switch (serverDef.getType()) { + ConnectionConfiguration getConnectionConfiguration(String databaseType) { + String driverClass; + String jdbdUrlTemplate; + switch (databaseType) { case "ora12c": - driver = "oracle.jdbc.driver.OracleDriver"; - url = "jdbc:oracle:thin:@//%s:%d/%s"; + driverClass = "oracle.jdbc.driverClass.OracleDriver"; + jdbdUrlTemplate = "jdbc:oracle:thin:@//%s:%d/%s"; break; case "pgsql": - driver = "org.postgresql.Driver"; - url = "jdbc:postgresql://%s:%d/%s"; + driverClass = "org.postgresql.Driver"; + jdbdUrlTemplate = "jdbc:postgresql://%s:%d/%s"; break; default: throw new EidIllegalArgumentException( "20170728:150904", - "Given driver hasn't been recognised." + String.format("Given database type '%s' hasn't been recognised.", databaseType) ); } return new ConnectionConfiguration( - driver, - url + driverClass, + jdbdUrlTemplate ); } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointConfiguration.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointConfiguration.java index 63dc852..d19f121 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointConfiguration.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointConfiguration.java @@ -6,7 +6,6 @@ import org.springframework.jdbc.datasource.DriverManagerDataSource; import pl.gov.coi.cascades.server.domain.DatabaseTemplateGateway; -import java.util.HashMap; import java.util.Map; /** @@ -18,29 +17,30 @@ public class DatabaseEndpointConfiguration { @Bean - Map produceDriverManagerDataSource(ServerConfigurationService service, - ConnectionConfigurator connectionConfigurator) { - Map managers = new HashMap<>(); - for (ServerDef serverDef : service.getManagedServers()) { - ConnectionConfiguration configuration = connectionConfigurator.getConnectionConfiguration(serverDef); - DriverManagerDataSource manager = new DriverManagerDataSource(); - manager.setDriverClassName(configuration.getDriver()); - manager.setUrl(String.format( - configuration.getUrl(), - serverDef.getHost(), - serverDef.getPort(), - serverDef.getDbname()) - ); - manager.setPassword(serverDef.getPassword()); - manager.setUsername(serverDef.getUser()); - managers.put(serverDef.getServerId(), manager); - } - return managers; + Map produceDriverManagerDataSource(DriverManagerDataSourceHelper driverManagerDataSourceHelper) { + return driverManagerDataSourceHelper.getManagersMap(); } @Bean - DatabaseManager produceDatabaseManager(Map driver) { - return new DatabaseEndpointManager(driver); + DriverManagerDataSourceProvider produceDriverManagerDataSourceProvider() { + return new DriverManagerDataSourceProviderImpl(); + } + + @Bean + DriverManagerDataSourceHelper produceDriverManagerDataSourceHelper(ConnectionConfigurator connectionConfigurator, + ServerConfigurationService serverConfigurationService, + DriverManagerDataSourceProvider driverManagerDataSourceProvider) { + return new DriverManagerDataSourceHelper( + connectionConfigurator, + serverConfigurationService, + driverManagerDataSourceProvider + ); + } + + @Bean + DatabaseManager produceDatabaseManager(Map driverManagerMap, + DriverManagerDataSourceHelper driverManagerDataSourceHelper) { + return new DatabaseEndpointManager(driverManagerMap, driverManagerDataSourceHelper); } @Bean diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointManager.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointManager.java index 46a553f..7cd215d 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointManager.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseEndpointManager.java @@ -5,7 +5,6 @@ import pl.wavesoftware.eid.exceptions.EidIllegalArgumentException; import javax.inject.Inject; -import java.sql.SQLException; import java.util.Map; /** @@ -15,14 +14,17 @@ public class DatabaseEndpointManager implements DatabaseManager { private final Map managers; + private final DriverManagerDataSourceHelper driverManagerDataSourceHelper; @Inject - DatabaseEndpointManager(Map managers) { + DatabaseEndpointManager(Map managers, + DriverManagerDataSourceHelper driverManagerDataSourceHelper) { this.managers = managers; + this.driverManagerDataSourceHelper = driverManagerDataSourceHelper; } @Override - public ConnectionDatabase get(String serverId) throws SQLException { + public ConnectionDatabase getConnectionToServer(String serverId) { DriverManagerDataSource manager = managers.get(serverId); if (manager == null) { @@ -38,4 +40,13 @@ public ConnectionDatabase get(String serverId) throws SQLException { ); } + @Override + public ConnectionDatabase getConnectionToTemplate(String serverId, String templateName) { + DriverManagerDataSource manager = driverManagerDataSourceHelper.getManager(serverId, templateName); + return new ConnectionDatabase( + new JdbcTemplate(manager), + manager.getUrl() + ); + } + } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseManager.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseManager.java index cfdf0aa..4bb7895 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseManager.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DatabaseManager.java @@ -8,6 +8,19 @@ */ public interface DatabaseManager { - ConnectionDatabase get(String serverId) throws SQLException; + /** + * Returns connection to database with sepcified serverId. + * @param serverId server ID + * @return connection to database + */ + ConnectionDatabase getConnectionToServer(String serverId) throws SQLException; + + /** + * Returns connection to template in database with sepcified serverId. + * @param serverId server ID + * @param templateName template name + * @return connection to database + */ + ConnectionDatabase getConnectionToTemplate(String serverId, String templateName) throws SQLException; } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelper.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelper.java new file mode 100644 index 0000000..603a0b1 --- /dev/null +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelper.java @@ -0,0 +1,83 @@ +package pl.gov.coi.cascades.server; + +import org.springframework.jdbc.datasource.DriverManagerDataSource; +import pl.wavesoftware.eid.exceptions.EidIllegalStateException; + +import javax.inject.Inject; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * @author Mariusz Wyszomierski + */ +public class DriverManagerDataSourceHelper { + + private final ConnectionConfigurator connectionConfigurator; + private final ServerConfigurationService serverConfigurationService; + private final DriverManagerDataSourceProvider driverManagerDataSourceProvider; + + @Inject + public DriverManagerDataSourceHelper(ConnectionConfigurator connectionConfigurator, + ServerConfigurationService serverConfigurationService, + DriverManagerDataSourceProvider driverManagerDataSourceProvider) { + this.connectionConfigurator = connectionConfigurator; + this.serverConfigurationService = serverConfigurationService; + this.driverManagerDataSourceProvider = driverManagerDataSourceProvider; + } + + /** + * Returns connection to database with given database name on server with given serverId + * defined in application configuration {@link ServerConfigurationService}. + * + * @param serverId server ID + * @param databaseName database name + * @return {@link DriverManagerDataSource} + */ + DriverManagerDataSource getManager(String serverId, String databaseName) { + ServerDef serverConfiguration = getServerDef(serverId); + ConnectionConfiguration connectionConfiguration = connectionConfigurator.getConnectionConfiguration(serverConfiguration.getType()); + ServerDef newServerConfiguration = serverConfiguration.getWithNewDatabaseName(databaseName); + return createDriverManagerDataSource(connectionConfiguration, newServerConfiguration); + } + + /** + * Returns map of connections to servers defined in application configuration {@link ServerConfigurationService}. + * @return map of connections, serverId is the key + */ + Map getManagersMap() { + Map managers = new HashMap<>(); + for (ServerDef serverDef : serverConfigurationService.getManagedServers()) { + ConnectionConfiguration configuration = connectionConfigurator.getConnectionConfiguration(serverDef.getType()); + DriverManagerDataSource manager = createDriverManagerDataSource(configuration, serverDef); + managers.put(serverDef.getServerId(), manager); + } + return managers; + } + + private DriverManagerDataSource createDriverManagerDataSource(ConnectionConfiguration connectionConfiguration, + ServerDef serverConfiguration) { + DriverManagerDataSource manager = driverManagerDataSourceProvider.produce(); + manager.setDriverClassName(connectionConfiguration.getDriverClass()); + manager.setUrl(String.format( + connectionConfiguration.getJdbcUrlTemplate(), + serverConfiguration.getHost(), + serverConfiguration.getPort(), + serverConfiguration.getDbname()) + ); + manager.setPassword(serverConfiguration.getPassword()); + manager.setUsername(serverConfiguration.getUser()); + return manager; + } + + private ServerDef getServerDef(String serverId) { + Optional matchingServerConfiguration = serverConfigurationService.getManagedServers().stream() + .filter(server -> serverId.equals(server.getServerId())) + .findFirst(); + if (!matchingServerConfiguration.isPresent()) { + String errorMessage = String.format("There is no configuration for serverId: %s", serverId); + throw new EidIllegalStateException("20180625:205951", errorMessage); + } + return matchingServerConfiguration.get(); + } +} diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProvider.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProvider.java new file mode 100644 index 0000000..e09df0c --- /dev/null +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProvider.java @@ -0,0 +1,15 @@ +package pl.gov.coi.cascades.server; + +import org.springframework.jdbc.datasource.DriverManagerDataSource; + +/** + * @author Mariusz Wyszomierski + */ +public interface DriverManagerDataSourceProvider { + + /** + * Provides instance of {@link DriverManagerDataSource}. + * @return {@link DriverManagerDataSource} + */ + DriverManagerDataSource produce(); +} diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImpl.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImpl.java new file mode 100644 index 0000000..6c55466 --- /dev/null +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImpl.java @@ -0,0 +1,14 @@ +package pl.gov.coi.cascades.server; + +import org.springframework.jdbc.datasource.DriverManagerDataSource; + +/** + * @author Mariusz Wyszomierski + */ +public class DriverManagerDataSourceProviderImpl implements DriverManagerDataSourceProvider { + + @Override + public DriverManagerDataSource produce() { + return new DriverManagerDataSource(); + } +} diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/GeneralTemplateGateway.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/GeneralTemplateGateway.java index c7cf476..9b97779 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/GeneralTemplateGateway.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/GeneralTemplateGateway.java @@ -41,45 +41,62 @@ public class GeneralTemplateGateway implements DatabaseTemplateGateway { @Override public void createTemplate(Template template, Path deploySQLScriptPath) { try { - ConnectionDatabase connectionDatabase = databaseManager.get(template.getServerId()); - StringBuilder commands = new StringBuilder(); - String script = readFileAsString(deploySQLScriptPath); - - if (connectionDatabase.getType().contains("oracle")) { - commands.append(getOracleStartCommands(template)); - } else if (connectionDatabase.getType().contains("postgresql")) { - commands.append(getPostgresStartCommands(template)); - } - String[] queries = commands - .append(script) - .toString() - .split(";"); - for (String str : queries) { - connectionDatabase.getJdbcTemplate().execute(str); - } + ConnectionDatabase connectionDatabase = databaseManager.getConnectionToServer(template.getServerId()); + runCreateDatabaseCommand(connectionDatabase, template); + ConnectionDatabase connectionToTemplate = databaseManager.getConnectionToTemplate(template.getServerId(), template.getName()); + runDeployScript(connectionToTemplate, deploySQLScriptPath); + runAfterDeployScript(connectionToTemplate, template); } catch (SQLException e) { throw new EidIllegalArgumentException("20170711:151221", e); } } + private void runDeployScript(ConnectionDatabase connectionToTemplate, Path deploySQLScriptPath) { + String deployScript = readFileAsString(deploySQLScriptPath); + runSemicolonSeperatedSQL(connectionToTemplate, deployScript); + } + + private void runAfterDeployScript(ConnectionDatabase connectionToTemplate, Template template) { + if (connectionToTemplate.getType().contains("postgresql")) { + runSemicolonSeperatedSQL(connectionToTemplate, String.format( + "UPDATE pg_database SET datistemplate = TRUE WHERE datname = '%s';" + + "UPDATE pg_database SET datallowconn = FALSE WHERE datname = '%s'", + template.getName(), template.getName() + )); + } + } + + private void runCreateDatabaseCommand(ConnectionDatabase connectionDatabase, Template template) { + String createDatabaseCommand = ""; + if (connectionDatabase.getType().contains("oracle")) { + createDatabaseCommand = getOracleStartCommands(template); + } else if (connectionDatabase.getType().contains("postgresql")) { + createDatabaseCommand = getPostgresStartCommands(template); + } + runSemicolonSeperatedSQL(connectionDatabase, createDatabaseCommand); + } + + private void runSemicolonSeperatedSQL(ConnectionDatabase connectionDatabase, String createDatabaseCommand) { + String[] queries = createDatabaseCommand.split(";"); + for (String str : queries) { + connectionDatabase.getJdbcTemplate().execute(str); + } + } + @Override public void deleteTemplate(Template template) { try { - ConnectionDatabase connectionDatabase = databaseManager.get(template.getServerId()); + ConnectionDatabase connectionDatabase = databaseManager.getConnectionToServer(template.getServerId()); StringBuilder commands = new StringBuilder(); - if (connectionDatabase.getType().contains("ora12c")) { + if (connectionDatabase.getType().contains("oracle")) { commands.append(getOracleFinishCommands(template)); - } else if (connectionDatabase.getType().contains("pgsql")) { + } else if (connectionDatabase.getType().contains("postgresql")) { commands.append(getPostgresFinishCommands(template)); } - String[] queries = commands - .toString() - .split(";"); - for (String str : queries) { - connectionDatabase.getJdbcTemplate().execute(str); - } + runSemicolonSeperatedSQL(connectionDatabase, commands + .toString()); } catch (SQLException e) { throw new EidIllegalArgumentException("20170726:135511", e); } @@ -106,7 +123,7 @@ private static String readFileAsString(Path deploySQLScriptPath) { return fileData.toString(); } - private static StringBuilder getOracleStartCommands(Template template) { + private static String getOracleStartCommands(Template template) { StringBuilder commands = new StringBuilder(); String createQuery = String.format( "CREATE PLUGGABLE DATABASE %s ADMIN USER admin IDENTIFIED BY ksdn#2Hd;", @@ -117,17 +134,14 @@ private static StringBuilder getOracleStartCommands(Template template) { template.getName() ); commands.append(createQuery).append(alterQuery); - return commands; + return commands.toString(); } - private static StringBuilder getPostgresStartCommands(Template template) { - StringBuilder commands = new StringBuilder(); - String createQuery = String.format( + private static String getPostgresStartCommands(Template template) { + return String.format( "CREATE DATABASE %s TEMPLATE template0;", template.getName() ); - commands.append(createQuery); - return commands; } private static StringBuilder getOracleFinishCommands(Template template) { @@ -145,7 +159,9 @@ private static StringBuilder getOracleFinishCommands(Template template) { } @Override + @Deprecated public boolean canBeRemoved(Template template) { - return false; + //TODO: implement this + throw new UnsupportedOperationException(); } } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ServerDef.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ServerDef.java index cdf717c..0b9dd5e 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ServerDef.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/ServerDef.java @@ -2,19 +2,15 @@ import lombok.AllArgsConstructor; import lombok.Data; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.Setter; +import lombok.NoArgsConstructor; /** * @author Agnieszka Celuch * @since 26.07.17 */ @Data -@Getter -@Setter +@NoArgsConstructor @AllArgsConstructor -@RequiredArgsConstructor public class ServerDef { private String serverId; private String type; @@ -23,4 +19,21 @@ public class ServerDef { private String password; private String host; private int port; + + /** + * Get new {@link ServerDef} instance with the same data expect database name. + * @param newDatabaseName new database name + * @return new instance with new database name + */ + public ServerDef getWithNewDatabaseName(String newDatabaseName) { + return new ServerDef( + this.serverId, + this.type, + newDatabaseName, + this.user, + this.password, + this.host, + this.port + ); + } } diff --git a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfiguration.java b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfiguration.java index a3a028d..90768f6 100644 --- a/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfiguration.java +++ b/cascades-server/configuration/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfiguration.java @@ -5,9 +5,12 @@ import org.springframework.context.annotation.Profile; import pl.gov.coi.cascades.server.ProfileType; import pl.gov.coi.cascades.server.domain.DatabaseIdGateway; +import pl.gov.coi.cascades.server.domain.DatabaseInstanceGateway; +import pl.gov.coi.cascades.server.domain.DatabaseLimitGateway; import pl.gov.coi.cascades.server.domain.DatabaseTypeClassNameService; import pl.gov.coi.cascades.server.domain.TemplateIdGateway; import pl.gov.coi.cascades.server.domain.UserGateway; +import pl.gov.coi.cascades.server.persistance.hibernate.mapper.DatabaseInstanceMapper; import javax.transaction.Transactional; @@ -39,4 +42,16 @@ DatabaseIdGateway createDatabaseIdGateway(DatabaseTypeClassNameService databaseT ); } + @Bean + @Transactional + DatabaseInstanceGateway createDatabaseInstanceGateway() { + return new DatabaseInstanceGatewayImpl(); + } + + @Bean + @Transactional + DatabaseLimitGateway createDatabaseLimitGateway() { + return new DatabaseLimitGatewayImpl(); + } + } diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfigurationTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfigurationTest.java index e708388..b76cfc9 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfigurationTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfigurationTest.java @@ -32,7 +32,7 @@ public void testGetDriver() throws Exception { ); // when - String actual = connectionConfiguration.getDriver(); + String actual = connectionConfiguration.getDriverClass(); // then assertThat(actual).isNotNull(); @@ -50,7 +50,7 @@ public void testGetUrl() throws Exception { ); // when - String actual = connectionConfiguration.getUrl(); + String actual = connectionConfiguration.getJdbcUrlTemplate(); // then assertThat(actual).isNotNull(); diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfiguratorTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfiguratorTest.java index c13c35e..ab5ab97 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfiguratorTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ConnectionConfiguratorTest.java @@ -3,7 +3,6 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; import pl.wavesoftware.eid.exceptions.EidIllegalArgumentException; @@ -16,101 +15,54 @@ */ public class ConnectionConfiguratorTest { - @Mock - private ServerConfigurationService service; - @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); @Rule public ExpectedException expectedException = ExpectedException.none(); + private ConnectionConfigurator connectionConfigurator = new ConnectionConfigurator(); + @Test - public void testGetConnectionConfigurationWhenThereIsError() throws Exception { + public void testGetConnectionConfigurationForNotSupportedType() { // given - String serverId = "Baza_dla_testu_C2DEV"; - String type = "mysql"; - String dbname = "C2DEV"; - String user = "C##DEPLOY"; - String password = "ksSdf#231n#dD"; - String host = "172.31.20.24"; - int port = 1521; - ServerDef serverDef = new ServerDef( - serverId, - type, - dbname, - user, - password, - host, - port - ); - ConnectionConfigurator connectionConfigurator = new ConnectionConfigurator(); + String notSupportedType = "mysql"; // then expectedException.expect(EidIllegalArgumentException.class); expectedException.expectMessage("20170728:150904"); - expectedException.expectMessage("Given driver hasn't been recognised."); + expectedException.expectMessage("Given database type 'mysql' hasn't been recognised."); // when - connectionConfigurator.getConnectionConfiguration(serverDef); + connectionConfigurator.getConnectionConfiguration(notSupportedType); } @Test - public void testGetConnectionConfigurationWhenThereIsOracleDriver() throws Exception { + public void testGetConnectionConfigurationForOracle() { // given - String serverId = "Baza_dla_testu_C2DEV"; - String type = "ora12c"; - String dbname = "C2DEV"; - String user = "C##DEPLOY"; - String password = "ksSdf#231n#dD"; - String host = "172.31.20.24"; - int port = 1521; - ServerDef serverDef = new ServerDef( - serverId, - type, - dbname, - user, - password, - host, - port - ); - ConnectionConfigurator connectionConfigurator = new ConnectionConfigurator(); + String oracleType = "ora12c"; // when - ConnectionConfiguration actual = connectionConfigurator.getConnectionConfiguration(serverDef); + ConnectionConfiguration actual = connectionConfigurator.getConnectionConfiguration(oracleType); // then assertThat(actual).isNotNull(); - assertThat(actual.getUrl()).contains("oracle"); + assertThat(actual.getDriverClass()).isEqualTo("oracle.jdbc.driverClass.OracleDriver"); + assertThat(actual.getJdbcUrlTemplate()).isEqualTo("jdbc:oracle:thin:@//%s:%d/%s"); } @Test - public void testGetConnectionConfigurationWhenThereIsPostgresDriver() throws Exception { + public void testGetConnectionConfigurationForPostgreSQL() { // given - String serverId = "Baza_dla_testu_postgres"; - String type = "pgsql"; - String dbname = "postgres"; - String user = "postgres"; - String password = "12345678"; - String host = "localhost"; - int port = 1521; - ServerDef serverDef = new ServerDef( - serverId, - type, - dbname, - user, - password, - host, - port - ); - ConnectionConfigurator connectionConfigurator = new ConnectionConfigurator(); + String postgreSQLType = "pgsql"; // when - ConnectionConfiguration actual = connectionConfigurator.getConnectionConfiguration(serverDef); + ConnectionConfiguration actual = connectionConfigurator.getConnectionConfiguration(postgreSQLType); // then assertThat(actual).isNotNull(); - assertThat(actual.getUrl()).contains("postgres"); + assertThat(actual.getDriverClass()).isEqualTo("org.postgresql.Driver"); + assertThat(actual.getJdbcUrlTemplate()).isEqualTo("jdbc:postgresql://%s:%d/%s"); } } diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointConfigurationTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointConfigurationTest.java index 98bed68..2cae103 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointConfigurationTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointConfigurationTest.java @@ -12,6 +12,7 @@ import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; /** * @author Agnieszka Celuch @@ -22,71 +23,95 @@ public class DatabaseEndpointConfigurationTest { @Mock private DatabaseManager databaseManager; + @Mock + private DriverManagerDataSourceHelper driverManagerDataSourceHelper; + @Mock private ConnectionConfigurator connectionConfigurator; @Mock - private ServerConfigurationService service; + private ServerConfigurationService serverConfigurationService; + + @Mock + private DriverManagerDataSourceProvider driverManagerDataSourceProvider; @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Test - public void testProduceConnectionConfiguration() throws Exception { - // given - DatabaseEndpointConfiguration conf = new DatabaseEndpointConfiguration(); + private DatabaseEndpointConfiguration databaseEndpointConfiguration = new DatabaseEndpointConfiguration(); + @Test + public void testProduceConnectionConfiguration() { // when - ConnectionConfigurator actual = conf.produceConnectionConfiguration(); + ConnectionConfigurator actual = databaseEndpointConfiguration.produceConnectionConfiguration(); // then assertThat(actual).isNotNull(); } @Test - public void testProduceDriverManagerDataSourceWhenMapIsEmpty() throws Exception { + public void testProduceDriverManagerDataSourceWhenMapIsEmpty() { // given - DatabaseEndpointConfiguration conf = new DatabaseEndpointConfiguration(); + Map expectedMap = new HashMap<>(); + when(driverManagerDataSourceHelper.getManagersMap()).thenReturn(expectedMap); // when - Map actual = conf.produceDriverManagerDataSource( - service, - connectionConfigurator + Map actual = databaseEndpointConfiguration.produceDriverManagerDataSource( + driverManagerDataSourceHelper ); // then - assertThat(actual).isEmpty(); + assertThat(actual).isEqualTo(expectedMap); } @Test - public void testProduceDatabaseTemplateGateway() throws Exception { - // given - DatabaseEndpointConfiguration conf = new DatabaseEndpointConfiguration(); - + public void testProduceDatabaseTemplateGateway() { // when - DatabaseTemplateGateway actual = conf.produceDatabaseTemplateGateway( + DatabaseTemplateGateway actual = databaseEndpointConfiguration.produceDatabaseTemplateGateway( databaseManager ); // then assertThat(actual).isNotNull(); - assertThat(actual).isInstanceOf(DatabaseTemplateGateway.class); + assertThat(actual).isInstanceOf(GeneralTemplateGateway.class); } @Test - public void testProduceDatabaseManager() throws Exception { + public void testProduceDatabaseManager() { // given - DatabaseEndpointConfiguration conf = new DatabaseEndpointConfiguration(); Map drivers = new HashMap<>(); // when - DatabaseManager actual = conf.produceDatabaseManager( - drivers + DatabaseManager actual = databaseEndpointConfiguration.produceDatabaseManager( + drivers, + driverManagerDataSourceHelper + ); + + // then + assertThat(actual).isNotNull(); + assertThat(actual).isInstanceOf(DatabaseEndpointManager.class); + } + + @Test + public void testProduceDriverManagerDataSourceHelper() { + // when + DriverManagerDataSourceHelper actual = databaseEndpointConfiguration.produceDriverManagerDataSourceHelper( + connectionConfigurator, + serverConfigurationService, + driverManagerDataSourceProvider ); // then assertThat(actual).isNotNull(); - assertThat(actual).isInstanceOf(DatabaseManager.class); + } + + @Test + public void testProduceDriverManagerDataSourceProvider() { + // when + DriverManagerDataSourceProvider actual = databaseEndpointConfiguration.produceDriverManagerDataSourceProvider(); + + // then + assertThat(actual).isNotNull(); } } diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointManagerTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointManagerTest.java index c834b23..e6bc5c3 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointManagerTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DatabaseEndpointManagerTest.java @@ -1,5 +1,6 @@ package pl.gov.coi.cascades.server; +import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; @@ -13,6 +14,7 @@ import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; /** * @author Agnieszka Celuch @@ -23,44 +25,62 @@ public class DatabaseEndpointManagerTest { @Mock private DriverManagerDataSource driverManagerDataSource; + @Mock + private DriverManagerDataSourceHelper driverManagerDataSourceHelper; + @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); @Rule public ExpectedException expectedException = ExpectedException.none(); - @Test - public void testGetWhenErrorOccurred() throws Exception { - // given + private DatabaseEndpointManager databaseEndpointManager; + + @Before + public void setup() { Map managerDataSourceMap = new HashMap<>(); managerDataSourceMap.put("test", driverManagerDataSource); - DatabaseEndpointManager databaseEndpointManager = new DatabaseEndpointManager( - managerDataSourceMap + databaseEndpointManager = new DatabaseEndpointManager( + managerDataSourceMap, + driverManagerDataSourceHelper ); + when(driverManagerDataSource.getUrl()).thenReturn("jdbc://database:123"); + } + @Test + public void testGetWhenErrorOccurred() { // then expectedException.expect(EidIllegalArgumentException.class); expectedException.expectMessage("20170726:121616"); expectedException.expectMessage("Given serverId hasn't been found."); // when - databaseEndpointManager.get("not_existing_key"); + databaseEndpointManager.getConnectionToServer("not_existing_key"); } @Test - public void testGet() throws Exception { + public void testGetConnectionToServer() { + // when + ConnectionDatabase actual = databaseEndpointManager.getConnectionToServer("test"); + + // then + assertThat(actual).isNotNull(); + assertThat(actual.getType()).isEqualTo("jdbc://database:123"); + assertThat(actual.getJdbcTemplate().getDataSource()).isEqualTo(driverManagerDataSource); + } + + @Test + public void testGetConnectionToTemplate() { // given - Map managerDataSourceMap = new HashMap<>(); - managerDataSourceMap.put("test", driverManagerDataSource); - DatabaseEndpointManager databaseEndpointManager = new DatabaseEndpointManager( - managerDataSourceMap - ); + when(driverManagerDataSourceHelper.getManager("serverId", "templateName")).thenReturn(driverManagerDataSource); // when - ConnectionDatabase actual = databaseEndpointManager.get("test"); + ConnectionDatabase actual = databaseEndpointManager.getConnectionToTemplate("serverId", "templateName"); // then assertThat(actual).isNotNull(); + assertThat(actual.getType()).isEqualTo("jdbc://database:123"); + assertThat(actual.getJdbcTemplate().getDataSource()).isEqualTo(driverManagerDataSource); } } diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelperTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelperTest.java new file mode 100644 index 0000000..37c5760 --- /dev/null +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceHelperTest.java @@ -0,0 +1,129 @@ +package pl.gov.coi.cascades.server; + +import org.assertj.core.util.Lists; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; +import org.springframework.jdbc.datasource.DriverManagerDataSource; +import pl.wavesoftware.eid.exceptions.EidIllegalStateException; + +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Mariusz Wyszomierski + */ +public class DriverManagerDataSourceHelperTest { + + @InjectMocks + private DriverManagerDataSourceHelper dataSourceHelper; + + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + + @Rule + public ExpectedException expectedException = ExpectedException.none(); + + @Mock + private ServerConfigurationService serverConfigurationService; + + @Mock + private DriverManagerDataSourceProvider driverManagerDataSourceProvider; + + @Mock + private DriverManagerDataSource driverManagerDataSource; + + @Mock + private ConnectionConfigurator connectionConfigurator; + + private static ServerDef SERVER_DEF; + private static ConnectionConfiguration CONNECTION_CONFIGURATION; + + @Before + public void setup() { + String serverId = "serverId"; + String type = "oracle"; + String dbname = "dev"; + String user = "user"; + String password = "password"; + String host = "host.db"; + int port = 123; + SERVER_DEF = new ServerDef( + serverId, + type, + dbname, + user, + password, + host, + port + ); + String urlTemplate = "jdbc://%s:%s/%s"; + String driverClass = "db.driver.class"; + CONNECTION_CONFIGURATION = new ConnectionConfiguration(driverClass, urlTemplate); + when(serverConfigurationService.getManagedServers()).thenReturn(Lists.newArrayList( + SERVER_DEF + )); + when(connectionConfigurator.getConnectionConfiguration(type)).thenReturn(CONNECTION_CONFIGURATION); + when(driverManagerDataSourceProvider.produce()).thenReturn(driverManagerDataSource); + } + + @Test + public void testGetManager() { + //when + DriverManagerDataSource result = dataSourceHelper.getManager("serverId", "databaseName"); + + //then + assertDriverManagerDataSource(result, "jdbc://host.db:123/databaseName"); + } + + @Test + public void testGetManagerWhenServerIdDoesntExists() { + //then + expectedException.expect(EidIllegalStateException.class); + expectedException.expectMessage("20180625:205951"); + expectedException.expectMessage("There is no configuration for serverId: NotExistingServerId"); + + //when + dataSourceHelper.getManager("NotExistingServerId", "databaseName"); + } + + @Test + public void testGetManagersMap() { + //when + Map resultMap = dataSourceHelper.getManagersMap(); + + //then + assertThat(resultMap.size()).isEqualTo(1); + DriverManagerDataSource dataSource = resultMap.get("serverId"); + assertDriverManagerDataSource(dataSource, "jdbc://host.db:123/dev"); + } + + private void assertDriverManagerDataSource(DriverManagerDataSource dataSource, String url) { + assertThat(dataSource).isNotNull(); + assertThat(dataSource).isEqualTo(driverManagerDataSource); + verify(driverManagerDataSource).setDriverClassName(CONNECTION_CONFIGURATION.getDriverClass()); + verify(driverManagerDataSource).setUrl(url); + verify(driverManagerDataSource).setPassword(SERVER_DEF.getPassword()); + verify(driverManagerDataSource).setUsername(SERVER_DEF.getUser()); + } + + @Test + public void testGetManagersMapReturnEmptyMap() { + //given + when(serverConfigurationService.getManagedServers()).thenReturn(Lists.emptyList()); + + //when + Map resultMap = dataSourceHelper.getManagersMap(); + + //then + assertThat(resultMap.size()).isEqualTo(0); + } +} diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImplTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImplTest.java new file mode 100644 index 0000000..796a851 --- /dev/null +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/DriverManagerDataSourceProviderImplTest.java @@ -0,0 +1,20 @@ +package pl.gov.coi.cascades.server; + +import org.junit.Test; +import org.springframework.jdbc.datasource.DriverManagerDataSource; + +import static org.assertj.core.api.Assertions.assertThat; + +public class DriverManagerDataSourceProviderImplTest { + + private DriverManagerDataSourceProviderImpl provider = new DriverManagerDataSourceProviderImpl(); + + @Test + public void produce() { + //when + DriverManagerDataSource result = provider.produce(); + + //then + assertThat(result).isNotNull(); + } +} diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/GeneralTemplateGatewayTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/GeneralTemplateGatewayTest.java new file mode 100644 index 0000000..35afec8 --- /dev/null +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/GeneralTemplateGatewayTest.java @@ -0,0 +1,185 @@ +package pl.gov.coi.cascades.server; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; +import org.springframework.jdbc.core.JdbcTemplate; +import pl.gov.coi.cascades.contract.domain.Template; +import pl.wavesoftware.eid.exceptions.EidIllegalArgumentException; +import pl.wavesoftware.eid.exceptions.EidIllegalStateException; + +import java.nio.file.Path; +import java.nio.file.Paths; +import java.sql.SQLException; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Mariusz Wyszomierski + */ +public class GeneralTemplateGatewayTest { + + private static final String POSTGRESQL = "postgresql"; + private static final String SERVER_ID = "serverId"; + private static final String ORACLE = "oracle"; + private static final String DEPLOY_SCRIPT_CONTENT = "insert into some_table values ('test')"; + + + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + + @Rule + public ExpectedException expectedException = ExpectedException.none(); + + @Mock + private DatabaseManager databaseManager; + + @Mock + private ConnectionDatabase connectionDatabase; + + @Mock + private JdbcTemplate jdbcTemplate; + + private GeneralTemplateGateway generalTemplateGateway; + private Template template = Template.builder().serverId(SERVER_ID).name("templateName").build(); + private Path deployScript = Paths.get("src","test","resources", "deploy.sql"); + + @Before + public void setup() throws SQLException { + generalTemplateGateway = new GeneralTemplateGateway(databaseManager); + when(databaseManager.getConnectionToServer(SERVER_ID)).thenReturn(connectionDatabase); + when(connectionDatabase.getJdbcTemplate()).thenReturn(jdbcTemplate); + when(databaseManager.getConnectionToTemplate(SERVER_ID, "templateName")).thenReturn(connectionDatabase); + } + + @Test + public void shouldRunCreateDatabaseCommandInPostgreSQL() { + //given + when(connectionDatabase.getType()).thenReturn(POSTGRESQL); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + verify(jdbcTemplate).execute("CREATE DATABASE templateName TEMPLATE template0"); + } + + @Test + public void shouldRunDeployScriptInPostgreSQL() { + //given + when(connectionDatabase.getType()).thenReturn(POSTGRESQL); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + verify(jdbcTemplate).execute(DEPLOY_SCRIPT_CONTENT); + } + + @Test + public void shouldChangeTemplateAttributesInPostgreSQL() { + //given + when(connectionDatabase.getType()).thenReturn(POSTGRESQL); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + verify(jdbcTemplate).execute("UPDATE pg_database SET datistemplate = TRUE WHERE datname = 'templateName'"); + verify(jdbcTemplate).execute("UPDATE pg_database SET datallowconn = FALSE WHERE datname = 'templateName'"); + } + + @Test + public void shouldRunCreateDatabaseCommandInOracle() { + //given + when(connectionDatabase.getType()).thenReturn(ORACLE); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + verify(jdbcTemplate).execute("CREATE PLUGGABLE DATABASE templateName ADMIN USER admin IDENTIFIED BY ksdn#2Hd"); + verify(jdbcTemplate).execute("ALTER PLUGGABLE DATABASE templateName OPEN READ WRITE"); + } + + @Test + public void shouldRunDeployScriptInOracle() { + //given + when(connectionDatabase.getType()).thenReturn(ORACLE); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + verify(jdbcTemplate).execute(DEPLOY_SCRIPT_CONTENT); + } + + @Test(expected = EidIllegalArgumentException.class) + public void shouldThrowIllegalArgumentExceptionCreateTemplate() throws SQLException { + //given + when(databaseManager.getConnectionToServer(SERVER_ID)).thenThrow(new SQLException()); + + //when + generalTemplateGateway.createTemplate(template, deployScript); + + //then + expectedException.expectMessage("20170711:151221"); + } + + @Test + public void deleteTemplatePostgreSQL() { + //given + when(connectionDatabase.getType()).thenReturn(POSTGRESQL); + + //when + generalTemplateGateway.deleteTemplate(template); + + //then + verify(jdbcTemplate).execute("DROP DATABASE templateName"); + } + + @Test + public void deleteTemplateOracle() { + //given + when(connectionDatabase.getType()).thenReturn(ORACLE); + + //when + generalTemplateGateway.deleteTemplate(template); + + //then + verify(jdbcTemplate).execute("ALTER PLUGGABLE DATABASE templateName CLOSE IMMEDIATE"); + verify(jdbcTemplate).execute("DROP PLUGGABLE DATABASE templateName INCLUDING DATAFILES"); + } + + @Test(expected = EidIllegalArgumentException.class) + public void deleteTemplateShouldThrowIllegalArgumentException() throws SQLException { + //given + when(databaseManager.getConnectionToServer(SERVER_ID)).thenThrow(new SQLException()); + + //when + generalTemplateGateway.deleteTemplate(template); + + //then + expectedException.expectMessage("20170726:135511"); + } + + @Test(expected = UnsupportedOperationException.class) + public void canBeRemoved() { + generalTemplateGateway.canBeRemoved(template); + } + + @Test(expected = EidIllegalStateException.class) + public void shouldThrowExceptionWhenDeployScriptDoesntExistsCreateTemplate() { + //given + when(connectionDatabase.getType()).thenReturn(POSTGRESQL); + + //when + generalTemplateGateway.createTemplate(template, Paths.get("incorrectPath")); + } +} diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ServerDefTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ServerDefTest.java index 5a134ef..04fad43 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ServerDefTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/ServerDefTest.java @@ -13,21 +13,25 @@ public class ServerDefTest { @Test public void testConstructorWithParameters() { // when - ServerDef serverDef = new ServerDef( - "test", - "ora12c", - "db_name", - "admin", - "pass123", - "172.0.0.1", - 1234 - ); + ServerDef serverDef = createFullServerDef(); // then assertThat(serverDef).isNotNull(); } + private ServerDef createFullServerDef() { + return new ServerDef( + "test", + "ora12c", + "db_name", + "admin", + "pass123", + "172.0.0.1", + 1234 + ); + } + @Test - public void testEquals() throws Exception { + public void testEquals() { // given ServerDef serverDef = new ServerDef(); ServerDef otherServerDef = new ServerDef(); @@ -41,7 +45,7 @@ public void testEquals() throws Exception { } @Test - public void testHashCode() throws Exception { + public void testHashCode() { // given ServerDef serverDef = new ServerDef(); ServerDef otherServerDef = new ServerDef(); @@ -55,7 +59,7 @@ public void testHashCode() throws Exception { } @Test - public void testCanEqual() throws Exception { + public void testCanEqual() { // given ServerDef serverDef = new ServerDef(); ServerDef otherServerDef = new ServerDef(); @@ -68,7 +72,7 @@ public void testCanEqual() throws Exception { } @Test - public void testToString() throws Exception { + public void testToString() { // given ServerDef serverDef = new ServerDef(); serverDef.setServerId("test"); @@ -92,7 +96,7 @@ public void testToString() throws Exception { } @Test - public void testSetServerId() throws Exception { + public void testSetServerId() { // given ServerDef serverDef = new ServerDef(); @@ -104,7 +108,7 @@ public void testSetServerId() throws Exception { } @Test - public void testSetDbname() throws Exception { + public void testSetDbname() { // given ServerDef serverDef = new ServerDef(); @@ -116,7 +120,7 @@ public void testSetDbname() throws Exception { } @Test - public void testSetUser() throws Exception { + public void testSetUser() { // given ServerDef serverDef = new ServerDef(); @@ -128,7 +132,7 @@ public void testSetUser() throws Exception { } @Test - public void testSetPassword() throws Exception { + public void testSetPassword() { // given ServerDef serverDef = new ServerDef(); @@ -140,7 +144,7 @@ public void testSetPassword() throws Exception { } @Test - public void testSetHost() throws Exception { + public void testSetHost() { // given ServerDef serverDef = new ServerDef(); @@ -152,7 +156,7 @@ public void testSetHost() throws Exception { } @Test - public void testSetPort() throws Exception { + public void testSetPort() { // given ServerDef serverDef = new ServerDef(); @@ -164,7 +168,7 @@ public void testSetPort() throws Exception { } @Test - public void testGetServerId() throws Exception { + public void testGetServerId() { // given ServerDef serverDef = new ServerDef(); @@ -176,7 +180,7 @@ public void testGetServerId() throws Exception { } @Test - public void testGetDbname() throws Exception { + public void testGetDbname() { // given ServerDef serverDef = new ServerDef(); serverDef.setDbname("db_name"); @@ -189,7 +193,7 @@ public void testGetDbname() throws Exception { } @Test - public void testGetUser() throws Exception { + public void testGetUser() { // given ServerDef serverDef = new ServerDef(); serverDef.setUser("admin"); @@ -202,7 +206,7 @@ public void testGetUser() throws Exception { } @Test - public void testGetPassword() throws Exception { + public void testGetPassword() { // given ServerDef serverDef = new ServerDef(); serverDef.setPassword("pass123"); @@ -215,7 +219,7 @@ public void testGetPassword() throws Exception { } @Test - public void testGetHost() throws Exception { + public void testGetHost() { // given ServerDef serverDef = new ServerDef(); serverDef.setHost("172.0.0.1"); @@ -228,7 +232,7 @@ public void testGetHost() throws Exception { } @Test - public void testGetPort() throws Exception { + public void testGetPort() { // given ServerDef serverDef = new ServerDef(); serverDef.setPort(1234); @@ -240,4 +244,16 @@ public void testGetPort() throws Exception { assertThat(actual).isEqualTo(1234); } + @Test + public void testGetWithNewDatabaseName() { + //given + ServerDef fullServerDef = createFullServerDef(); + + //when + ServerDef result = fullServerDef.getWithNewDatabaseName("NEW DATABASE NAME"); + + //then + assertThat(result.toString()).isEqualTo("ServerDef(serverId=test, type=ora12c, dbname=NEW DATABASE NAME, user=admin, password=pass123, host=172.0.0.1, port=1234)"); + } + } diff --git a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfigurationTest.java b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfigurationTest.java index adbc78d..27f8e59 100644 --- a/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfigurationTest.java +++ b/cascades-server/configuration/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/HibernateConfigurationTest.java @@ -6,6 +6,8 @@ import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; import pl.gov.coi.cascades.server.domain.DatabaseIdGateway; +import pl.gov.coi.cascades.server.domain.DatabaseInstanceGateway; +import pl.gov.coi.cascades.server.domain.DatabaseLimitGateway; import pl.gov.coi.cascades.server.domain.DatabaseTypeClassNameService; import pl.gov.coi.cascades.server.domain.TemplateIdGateway; import pl.gov.coi.cascades.server.domain.UserGateway; @@ -24,44 +26,55 @@ public class HibernateConfigurationTest { @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Test - public void testCreateTemplateIdGateway() throws Exception { - // given - HibernateConfiguration hibernateConfiguration = new HibernateConfiguration(); + private HibernateConfiguration hibernateConfiguration = new HibernateConfiguration(); + @Test + public void testCreateTemplateIdGateway() { // when TemplateIdGateway actual = hibernateConfiguration.createTemplateIdGateway(); // then - assertThat(actual).isInstanceOf(TemplateIdGatewayImpl.class); + assertThat(actual).isNotNull(); } @Test - public void testCreateUserGateway() throws Exception { - // given - HibernateConfiguration hibernateConfiguration = new HibernateConfiguration(); - + public void testCreateUserGateway() { // when UserGateway actual = hibernateConfiguration.createUserGateway( databaseTypeClassNameService ); // then - assertThat(actual).isInstanceOf(UserGatewayImpl.class); + assertThat(actual).isNotNull(); } @Test - public void testCreateDatabaseIdGateway() throws Exception { - // given - HibernateConfiguration hibernateConfiguration = new HibernateConfiguration(); - + public void testCreateDatabaseIdGateway() { // when DatabaseIdGateway actual = hibernateConfiguration.createDatabaseIdGateway( databaseTypeClassNameService ); // then - assertThat(actual).isInstanceOf(DatabaseIdGatewayImpl.class); + assertThat(actual).isNotNull(); + } + + @Test + public void testCreateDatabaseInstanceGateway() { + // when + DatabaseInstanceGateway actual = hibernateConfiguration.createDatabaseInstanceGateway(); + + // then + assertThat(actual).isNotNull(); + } + + @Test + public void testCreateDatabaseLimitGateway() { + // when + DatabaseLimitGateway actual = hibernateConfiguration.createDatabaseLimitGateway(); + + // then + assertThat(actual).isNotNull(); } } diff --git a/cascades-server/configuration/src/test/resources/deploy.sql b/cascades-server/configuration/src/test/resources/deploy.sql new file mode 100644 index 0000000..6767bba --- /dev/null +++ b/cascades-server/configuration/src/test/resources/deploy.sql @@ -0,0 +1 @@ +insert into some_table values ('test'); diff --git a/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImpl.java b/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImpl.java new file mode 100644 index 0000000..bb7b9a2 --- /dev/null +++ b/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImpl.java @@ -0,0 +1,51 @@ +package pl.gov.coi.cascades.server.persistance.hibernate; + +import com.google.common.annotations.VisibleForTesting; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import pl.gov.coi.cascades.server.domain.DatabaseInstance; +import pl.gov.coi.cascades.server.domain.DatabaseInstanceGateway; + +import javax.transaction.Transactional; + +/** + * @author Łukasz Małek + */ +@Transactional +public class DatabaseInstanceGatewayImpl implements DatabaseInstanceGateway { + + private static final Logger DEFAULT_LOGGER = LoggerFactory.getLogger(DatabaseInstanceGatewayImpl.class); + private Logger logger; + + public DatabaseInstanceGatewayImpl() { + this( + DEFAULT_LOGGER + ); + } + + @VisibleForTesting + DatabaseInstanceGatewayImpl(Logger logger) { + this.logger = logger; + } + + @Override + @Deprecated + public DatabaseInstance launchDatabase(DatabaseInstance databaseInstance) { + // TODO: write an implementation + throw new UnsupportedOperationException("Not yet implemented!"); + } + + @Override + @Deprecated + public void deleteDatabase(DatabaseInstance databaseInstance) { + // TODO: write an implementation + throw new UnsupportedOperationException("Not yet implemented!"); + } + + @Override + @Deprecated + public String getRemoteServerId() { + // TODO: write an implementation + throw new UnsupportedOperationException("Not yet implemented!"); + } +} diff --git a/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImpl.java b/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImpl.java new file mode 100644 index 0000000..3afe02d --- /dev/null +++ b/cascades-server/persistence-hibernate/src/main/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImpl.java @@ -0,0 +1,54 @@ +package pl.gov.coi.cascades.server.persistance.hibernate; + +import com.google.common.annotations.VisibleForTesting; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import pl.gov.coi.cascades.server.domain.DatabaseLimitGateway; +import pl.gov.coi.cascades.server.domain.User; + +import javax.transaction.Transactional; + +/** + * @author Łukasz Małek + */ +@Transactional +public class DatabaseLimitGatewayImpl implements DatabaseLimitGateway { + + private static final Logger DEFAULT_LOGGER = LoggerFactory.getLogger(DatabaseLimitGatewayImpl.class); + private Logger logger; + + public DatabaseLimitGatewayImpl() { + this( + DEFAULT_LOGGER + ); + } + + @VisibleForTesting + DatabaseLimitGatewayImpl(Logger logger) { + this.logger = logger; + } + + @Override + public boolean isPersonalLimitExceeded(User user) { + // TODO: write an implementation + return false; + } + + @Override + public int getPersonalLimitPerUser(User user) { + // TODO: write an implementation + return 100; + } + + @Override + public boolean isGlobalLimitExceeded() { + // TODO: write an implementation + return false; + } + + @Override + public int getGlobalLimit() { + // TODO: write an implementation + return 100; + } +} diff --git a/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImplTest.java b/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImplTest.java new file mode 100644 index 0000000..e96aa44 --- /dev/null +++ b/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseInstanceGatewayImplTest.java @@ -0,0 +1,40 @@ +package pl.gov.coi.cascades.server.persistance.hibernate; + +import org.junit.Rule; +import org.junit.Test; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; +import pl.gov.coi.cascades.server.domain.DatabaseInstance; + +/** + * @author Łukasz Małek + */ +public class DatabaseInstanceGatewayImplTest { + + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + + private DatabaseInstanceGatewayImpl databaseInstanceGateway = new DatabaseInstanceGatewayImpl(); + + @Test(expected = UnsupportedOperationException.class) + public void testLaunchDatabase() { + //when + databaseInstanceGateway.launchDatabase(getDatabaseInstance()); + } + + @Test(expected = UnsupportedOperationException.class) + public void testGetRemoteServerId() { + //when + databaseInstanceGateway.getRemoteServerId(); + } + + @Test(expected = UnsupportedOperationException.class) + public void testDeleteDatabase() { + //when + databaseInstanceGateway.deleteDatabase(getDatabaseInstance()); + } + + private DatabaseInstance getDatabaseInstance() { + return DatabaseInstance.builder().build(); + } +} diff --git a/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImplTest.java b/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImplTest.java new file mode 100644 index 0000000..b10e8c7 --- /dev/null +++ b/cascades-server/persistence-hibernate/src/test/java/pl/gov/coi/cascades/server/persistance/hibernate/DatabaseLimitGatewayImplTest.java @@ -0,0 +1,64 @@ +package pl.gov.coi.cascades.server.persistance.hibernate; + +import org.junit.Rule; +import org.junit.Test; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; +import pl.gov.coi.cascades.server.domain.User; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * @author Łukasz Małek + */ +public class DatabaseLimitGatewayImplTest { + + private static final String USERNAME = "username"; + private static final String ID = "id"; + private static final String EMAIL = "email"; + + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + + private DatabaseLimitGatewayImpl databaseLimitGateway = new DatabaseLimitGatewayImpl(); + + @Test + public void testIsPersonalLimitExceeded() { + //when + boolean result = databaseLimitGateway.isPersonalLimitExceeded(getUser()); + + //then + assertThat(result).isFalse(); + } + + @Test + public void testGetPersonalLimitPerUser() { + //when + int result = databaseLimitGateway.getPersonalLimitPerUser(getUser()); + + //then + assertThat(result).isEqualTo(100); + } + + @Test + public void testGlobalLimitExceeded() { + //when + boolean result = databaseLimitGateway.isGlobalLimitExceeded(); + + //then + assertThat(result).isFalse(); + } + + @Test + public void testGetGlobalLimit() { + //when + int result = databaseLimitGateway.getGlobalLimit(); + + //then + assertThat(result).isEqualTo(100); + } + + private User getUser() { + return new User(USERNAME, ID, EMAIL); + } +}