204 lines
8.1 KiB
Java
204 lines
8.1 KiB
Java
/*
|
|
* Copyright 2013 Robert von Burg <eitch@eitchnet.ch>
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package li.strolch.service.test;
|
|
|
|
import static li.strolch.db.DbConstants.PROP_DB_HOST_OVERRIDE;
|
|
import static li.strolch.runtime.configuration.DbConnectionBuilder.overridePostgresqlHost;
|
|
import static li.strolch.testbase.runtime.RuntimeMock.assertServiceResult;
|
|
|
|
import java.io.File;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.sql.Connection;
|
|
import java.sql.DriverManager;
|
|
|
|
import li.strolch.agent.api.ComponentContainer;
|
|
import li.strolch.agent.api.StrolchRealm;
|
|
import li.strolch.command.AbstractRealmCommandTest;
|
|
import li.strolch.db.DbSchemaVersionCheck;
|
|
import li.strolch.persistence.postgresql.PostgreSqlPersistenceHandler;
|
|
import li.strolch.privilege.model.Certificate;
|
|
import li.strolch.service.XmlImportModelArgument;
|
|
import li.strolch.service.XmlImportModelResult;
|
|
import li.strolch.service.XmlImportModelService;
|
|
import li.strolch.service.api.*;
|
|
import li.strolch.testbase.runtime.RuntimeMock;
|
|
import li.strolch.utils.Version;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.postgresql.Driver;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* @author Robert von Burg <eitch@eitchnet.ch>
|
|
*/
|
|
public abstract class AbstractRealmServiceTest<T extends ServiceArgument, U extends ServiceResult> {
|
|
|
|
public static final String REALM_CACHED = "svcCached";
|
|
public static final String REALM_CACHED_AUDITS_VERSIONING = "svcCachedAuditsVersioning";
|
|
public static final String REALM_TRANSIENT = "svcTransient";
|
|
public static final String RUNTIME_PATH = "target/svcTestRuntime/";
|
|
public static final String CONFIG_SRC = "src/test/resources/svctest";
|
|
|
|
protected static final Logger logger = LoggerFactory.getLogger(AbstractRealmServiceTest.class);
|
|
|
|
protected static RuntimeMock runtimeMock;
|
|
protected Certificate certificate;
|
|
|
|
protected String getUsername() {
|
|
return "test";
|
|
}
|
|
|
|
@Before
|
|
public void before() throws Exception {
|
|
|
|
dropSchema(AbstractRealmServiceTest.class.getSimpleName(), "jdbc:postgresql://localhost/cacheduserdb",
|
|
"cacheduser", "test");
|
|
dropSchema(AbstractRealmServiceTest.class.getSimpleName(),
|
|
"jdbc:postgresql://localhost/cacheduserauditsversioningdb", "cacheduserauditsversioning", "test");
|
|
|
|
File rootPath = new File(RUNTIME_PATH);
|
|
File configSrc = new File(CONFIG_SRC);
|
|
runtimeMock = new RuntimeMock();
|
|
runtimeMock.mockRuntime(rootPath, configSrc);
|
|
runtimeMock.startContainer();
|
|
|
|
this.certificate = runtimeMock.getPrivilegeHandler().authenticate(getUsername(), getUsername().toCharArray());
|
|
importFromXml(REALM_CACHED, this.certificate, getServiceHandler());
|
|
importFromXml(REALM_CACHED_AUDITS_VERSIONING, this.certificate, getServiceHandler());
|
|
}
|
|
|
|
@After
|
|
public void after() {
|
|
if (runtimeMock != null)
|
|
runtimeMock.destroyRuntime();
|
|
}
|
|
|
|
public static void dropSchema(String ctx, String dbUrl, String dbUsername, String dbPassword) throws Exception {
|
|
|
|
if (System.getProperties().containsKey(PROP_DB_HOST_OVERRIDE))
|
|
dbUrl = overridePostgresqlHost(ctx, dbUrl);
|
|
|
|
if (!Driver.isRegistered())
|
|
Driver.register();
|
|
|
|
Version dbVersion = DbSchemaVersionCheck.getExpectedDbVersion(
|
|
PostgreSqlPersistenceHandler.SCRIPT_PREFIX_STROLCH, PostgreSqlPersistenceHandler.class);
|
|
String sql = DbSchemaVersionCheck.getSql(PostgreSqlPersistenceHandler.SCRIPT_PREFIX_STROLCH,
|
|
PostgreSqlPersistenceHandler.class, dbVersion, "drop");
|
|
try (Connection connection = DriverManager.getConnection(dbUrl, dbUsername, dbPassword)) {
|
|
connection.prepareStatement(sql).execute();
|
|
}
|
|
}
|
|
|
|
public static void importFromXml(String realm, Certificate certificate, ServiceHandler serviceHandler) {
|
|
|
|
XmlImportModelService svc = new XmlImportModelService();
|
|
XmlImportModelArgument arg = new XmlImportModelArgument();
|
|
arg.realm = realm;
|
|
arg.modelFileName = "StrolchModel.xml";
|
|
ServiceResult result = serviceHandler.doService(certificate, svc, arg);
|
|
assertServiceResult(ServiceResultState.SUCCESS, XmlImportModelResult.class, result);
|
|
}
|
|
|
|
private void doService(String realm, ServiceResultState expectedState, Class<?> expectedServiceResultType,
|
|
Runner before, Runner validator, Runner after)
|
|
throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
|
|
|
|
Service<T, U> svc = getSvcClass().getConstructor().newInstance();
|
|
T arg = getArgInstance();
|
|
|
|
if (before != null)
|
|
before.run(runtimeMock.getContainer().getRealm(realm), runtimeMock.getContainer());
|
|
|
|
arg.realm = realm;
|
|
|
|
ServiceResult result = getServiceHandler().doService(this.certificate, svc, arg);
|
|
assertServiceResult(expectedState, expectedServiceResultType, result);
|
|
|
|
if (validator != null)
|
|
validator.run(runtimeMock.getContainer().getRealm(realm), runtimeMock.getContainer());
|
|
|
|
if (after != null)
|
|
after.run(runtimeMock.getContainer().getRealm(realm), runtimeMock.getContainer());
|
|
}
|
|
|
|
public static ServiceHandler getServiceHandler() {
|
|
return runtimeMock.getContainer().getComponent(ServiceHandler.class);
|
|
}
|
|
|
|
public interface Runner {
|
|
void run(StrolchRealm strolchRealm, ComponentContainer container);
|
|
}
|
|
|
|
protected abstract Class<? extends Service<T, U>> getSvcClass();
|
|
|
|
protected abstract T getArgInstance();
|
|
|
|
protected void runServiceInAllRealmTypes() {
|
|
runServiceInAllRealmTypes(null, null, null);
|
|
}
|
|
|
|
protected void runServiceInAllRealmTypes(Class<?> expectedServiceResultType) {
|
|
runServiceInAllRealmTypes(expectedServiceResultType, null, null, null);
|
|
}
|
|
|
|
protected void runServiceInAllRealmTypes(Runner before, Runner validator, Runner after) {
|
|
runServiceInAllRealmTypes(ServiceResult.class, before, validator, after);
|
|
}
|
|
|
|
protected void runServiceInAllRealmTypes(Class<?> expectedServiceResultType, Runner before, Runner validator,
|
|
Runner after) {
|
|
try {
|
|
|
|
runTransient(expectedServiceResultType, before, validator, after);
|
|
runCached(expectedServiceResultType, before, validator, after);
|
|
runCachedWithAuditsAndVersioning(expectedServiceResultType, before, validator, after);
|
|
} catch (InstantiationException | IllegalAccessException | InvocationTargetException |
|
|
NoSuchMethodException e) {
|
|
throw new RuntimeException("Failed to instantiate class " + getSvcClass().getName() + ": " + e.getMessage(),
|
|
e);
|
|
}
|
|
}
|
|
|
|
private void runCached(Class<?> expectedServiceResultType, Runner before, Runner validator, Runner after)
|
|
throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
|
|
doService(REALM_CACHED, ServiceResultState.SUCCESS, expectedServiceResultType, before, validator, after);
|
|
}
|
|
|
|
private void runCachedWithAuditsAndVersioning(Class<?> expectedServiceResultType, Runner before, Runner validator,
|
|
Runner after)
|
|
throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
|
|
doService(REALM_CACHED_AUDITS_VERSIONING, ServiceResultState.SUCCESS, expectedServiceResultType, before,
|
|
validator, after);
|
|
}
|
|
|
|
protected void runTransient()
|
|
throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
|
|
runTransient(null);
|
|
}
|
|
|
|
protected void runTransient(Class<?> expectedServiceResultType)
|
|
throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
|
|
runTransient(expectedServiceResultType, null, null, null);
|
|
}
|
|
|
|
private void runTransient(Class<?> expectedServiceResultType, Runner before, Runner validator, Runner after)
|
|
throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
|
|
doService(REALM_TRANSIENT, ServiceResultState.SUCCESS, expectedServiceResultType, before, validator, after);
|
|
}
|
|
}
|