luca.frosini
/
infrastructure-tests
13
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reorganizing tests 

git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/private/luca.frosini/infrastructure-tests@151088 82a268e6-3cf1-43bd-a215-b396298e98cf
This commit is contained in:
Luca Frosini 2017-07-14 09:11:50 +00:00
parent 473e4f0d68
commit 5fe99072dc
21 changed files with 347 additions and 782 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
pom.xml
View File

@ -73,12 +73,14 @@
<version>[1.0.1-SNAPSHOT, 2.0.0-SNAPSHOT)</version> <version>[1.0.1-SNAPSHOT, 2.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.reflections</groupId> <groupId>org.reflections</groupId>
<artifactId>reflections</artifactId> <artifactId>reflections</artifactId>
<version>0.9.10</version> <version>0.9.10</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<!--
<dependency> <dependency>
<groupId>org.gcube.data.publishing</groupId> <groupId>org.gcube.data.publishing</groupId>
<artifactId>document-store-lib-couchdb</artifactId> <artifactId>document-store-lib-couchdb</artifactId>
@ -97,7 +99,7 @@
<version>[1.0.1-SNAPSHOT, 2.0.0-SNAPSHOT)</version> <version>[1.0.1-SNAPSHOT, 2.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
-->
<dependency> <dependency>
<groupId>org.gcube.accounting</groupId> <groupId>org.gcube.accounting</groupId>
@ -111,13 +113,15 @@
<version>[2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT)</version> <version>[2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<!--
<dependency> <dependency>
<groupId>org.gcube.accounting</groupId> <groupId>org.gcube.accounting</groupId>
<artifactId>accounting-analytics-persistence-couchdb</artifactId> <artifactId>accounting-analytics-persistence-couchdb</artifactId>
<version>[2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT)</version> <version>[2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
-->
<dependency> <dependency>
<groupId>org.gcube.accounting</groupId> <groupId>org.gcube.accounting</groupId>
<artifactId>accounting-analytics-persistence-couchbase</artifactId> <artifactId>accounting-analytics-persistence-couchbase</artifactId>
@ -147,12 +151,7 @@
<version>[1.3.0-SNAPSHOT,2.0.0-SNAPSHOT)</version> <version>[1.3.0-SNAPSHOT,2.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency>
<groupId>org.gcube.accounting</groupId>
<artifactId>couchdb-cache-se-plugin</artifactId>
<version>[1.1.0-SNAPSHOT,2.0.0-SNAPSHOT)</version>
<scope>test</scope>
</dependency>
<dependency> <dependency>
<groupId>org.gcube.information-system</groupId> <groupId>org.gcube.information-system</groupId>
<artifactId>is-sweeper-se-plugin</artifactId> <artifactId>is-sweeper-se-plugin</artifactId>
@ -173,14 +172,6 @@
<version>[1.2.0-SNAPSHOT, 2.0.0-SNAPSHOT)</version> <version>[1.2.0-SNAPSHOT, 2.0.0-SNAPSHOT)</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<!--
<dependency>
<groupId>org.gcube.dataanalysis</groupId>
<artifactId>smart-generic-worker</artifactId>
<version>[1.0.1-SNAPSHOT, 2.0.0-SNAPSHOT)</version>
<scope>test</scope>
</dependency>
-->
<dependency> <dependency>
<groupId>org.gcube.information-system</groupId> <groupId>org.gcube.information-system</groupId>

44
src/test/java/org/gcube/accounting/analytics/persistence/AccountingPersistenceQueryConfigurationTest.java
View File

@ -3,10 +3,9 @@
*/ */
package org.gcube.accounting.analytics.persistence; package org.gcube.accounting.analytics.persistence;
import org.gcube.accounting.analytics.persistence.couchdb.AccountingPersistenceQueryCouchDB; import org.gcube.accounting.analytics.persistence.couchbase.AccountingPersistenceQueryCouchBase;
import org.gcube.accounting.persistence.AccountingPersistenceConfiguration; import org.gcube.accounting.persistence.AccountingPersistenceConfiguration;
import org.gcube.testutility.ScopedTest; import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUtility;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -18,37 +17,32 @@ import org.slf4j.LoggerFactory;
public class AccountingPersistenceQueryConfigurationTest extends ScopedTest { public class AccountingPersistenceQueryConfigurationTest extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(AccountingPersistenceQueryConfigurationTest.class); private static Logger logger = LoggerFactory.getLogger(AccountingPersistenceQueryConfigurationTest.class);
@Test @Test
public void accountingPersistenceQueryCouchDBConfigurationTest() throws Exception { public void accountingPersistenceQueryCouchDBConfigurationTest() throws Exception {
AccountingPersistenceBackendQueryConfiguration acbqc = AccountingPersistenceBackendQueryConfiguration acbqc = new AccountingPersistenceBackendQueryConfiguration(
new AccountingPersistenceBackendQueryConfiguration(AccountingPersistenceQueryCouchDB.class); AccountingPersistenceQueryCouchBase.class);
logger.debug("{}", acbqc); logger.debug("{}", acbqc);
} }
@Test // @Test
public void accountingPersistenceQueryCouchBaseConfigurationTest() throws Exception { public void getUsernamePasswordForScopes() throws Exception {
/*
AccountingPersistenceBackendQueryConfiguration acbqc =
new AccountingPersistenceBackendQueryConfiguration(AccountingPersistenceQueryCouchBase.class);
logger.debug("{}", acbqc);
*/
}
//@Test
public void getUsernamePasswordForScopes() throws Exception{
try { try {
AccountingPersistenceBackendQueryConfiguration persitenceConfiguration = new AccountingPersistenceBackendQueryConfiguration(AccountingPersistenceQueryCouchDB.class); AccountingPersistenceBackendQueryConfiguration persitenceConfiguration = new AccountingPersistenceBackendQueryConfiguration(
AccountingPersistenceQueryCouchBase.class);
String uri = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.URL_PROPERTY_KEY); String uri = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.URL_PROPERTY_KEY);
String username = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.USERNAME_PROPERTY_KEY); String username = persitenceConfiguration
String password = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.PASSWORD_PROPERTY_KEY); .getProperty(AccountingPersistenceConfiguration.USERNAME_PROPERTY_KEY);
logger.debug("{} {} - {} : {}", TestUtility.getScope(), uri, username, password); String password = persitenceConfiguration
}catch(IndexOutOfBoundsException e){ .getProperty(AccountingPersistenceConfiguration.PASSWORD_PROPERTY_KEY);
logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(), e.getMessage()); logger.debug("{} {} - {} : {}", ScopedTest.getCurrentContext(), uri, username, password);
} catch(Exception e){ } catch (IndexOutOfBoundsException e) {
logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(),
e.getMessage());
} catch (Exception e) {
logger.error("Error getting AccountingPersistenceConfiguration", e); logger.error("Error getting AccountingPersistenceConfiguration", e);
throw e; throw e;
} }
} }
} }

3
src/test/java/org/gcube/accounting/analytics/persistence/AccountingPersistenceQueryFactoryTest.java
View File

@ -10,7 +10,6 @@ import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.ektorp.DocumentNotFoundException;
import org.gcube.accounting.analytics.Filter; import org.gcube.accounting.analytics.Filter;
import org.gcube.accounting.analytics.Info; import org.gcube.accounting.analytics.Info;
import org.gcube.accounting.analytics.TemporalConstraint; import org.gcube.accounting.analytics.TemporalConstraint;
@ -83,7 +82,7 @@ public class AccountingPersistenceQueryFactoryTest extends ScopedTest {
} }
} }
@Test(expected = DocumentNotFoundException.class) @Test
public void testFakeFilters() throws Exception { public void testFakeFilters() throws Exception {
Calendar startTime = Calendar.getInstance(); Calendar startTime = Calendar.getInstance();
startTime.setTimeInMillis(startTime.getTimeInMillis() startTime.setTimeInMillis(startTime.getTimeInMillis()

203
src/test/java/org/gcube/accounting/analytics/persistence/couchdb/AccountingPersistenceQueryCouchDBTest.java
View File

@ -1,203 +0,0 @@
/**
*
*/
package org.gcube.accounting.analytics.persistence.couchdb;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import org.gcube.accounting.analytics.Filter;
import org.gcube.accounting.analytics.Info;
import org.gcube.accounting.analytics.NumberedFilter;
import org.gcube.accounting.analytics.TemporalConstraint;
import org.gcube.accounting.analytics.TemporalConstraint.AggregationMode;
import org.gcube.accounting.analytics.persistence.AccountingPersistenceBackendQueryConfiguration;
import org.gcube.accounting.analytics.persistence.AccountingPersistenceQuery;
import org.gcube.accounting.analytics.persistence.AccountingPersistenceQueryFactory;
import org.gcube.accounting.datamodel.aggregation.AggregatedServiceUsageRecord;
import org.gcube.testutility.ScopedTest;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Luca Frosini (ISTI - CNR)
*
*/
public class AccountingPersistenceQueryCouchDBTest extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(AccountingPersistenceQueryCouchDBTest.class);
protected AccountingPersistenceQueryCouchDB accountingPersistenceQueryCouchDB;
@Before
public void before() throws Exception{
AccountingPersistenceBackendQueryConfiguration configuration = new
AccountingPersistenceBackendQueryConfiguration(AccountingPersistenceQueryCouchDB.class);
/*
configuration.addProperty(AccountingPersistenceQueryCouchDB.DB_NAME, "my_couchapp_test");
String url = configuration.getProperty(AccountingPersistenceQueryCouchDB.URL_PROPERTY_KEY);
url = url.replace("accounting-d-d4s.d4science.org", "couchdb01-d-d4s.d4science.org:5984");
configuration.addProperty(AccountingPersistenceQueryCouchDB.URL_PROPERTY_KEY, url);
*/
accountingPersistenceQueryCouchDB = new AccountingPersistenceQueryCouchDB();
accountingPersistenceQueryCouchDB.prepareConnection(configuration);
}
public static <V> String printCalendarMap(Map<Calendar, V> map){
StringBuilder stringBuilder = new StringBuilder();
for(Calendar calendar : map.keySet()){
V v = map.get(calendar);
stringBuilder.append(v.toString());
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
public static <T, V> String printMap(Map<T, ? extends Map<Calendar, V>> map){
StringBuilder stringBuilder = new StringBuilder();
for(T t : map.keySet()) {
stringBuilder.append(t.toString());
stringBuilder.append("\n");
Map<Calendar, V> innerMap = map.get(t);
stringBuilder.append(printCalendarMap(innerMap));
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
@Test
public void testTimeSeriesEmptyFilter() throws Exception {
Calendar startTime = Calendar.getInstance();
startTime.set(2016, Calendar.JANUARY, 1);
Calendar endTime = Calendar.getInstance();
List<Filter> filters = new ArrayList<Filter>();
TemporalConstraint temporalConstraint =
new TemporalConstraint(startTime.getTimeInMillis(),
endTime.getTimeInMillis(), AggregationMode.DAILY);
logger.trace("\n\n");
Class<AggregatedServiceUsageRecord> clz =
AggregatedServiceUsageRecord.class;
SortedMap<Calendar, Info> timeSeries =
accountingPersistenceQueryCouchDB.getTimeSeries(clz,
temporalConstraint, filters);
logger.debug("Backend: Time Series for {}:\n{}", filters,
printCalendarMap(timeSeries));
AccountingPersistenceQuery apq =
AccountingPersistenceQueryFactory.getInstance();
timeSeries = apq.getTimeSeries(clz,temporalConstraint, filters, true);
logger.debug("Factory: Time Series for {}:\n{}", filters,
printCalendarMap(timeSeries));
}
@Test
public void testTop() throws Exception {
Calendar startTime = Calendar.getInstance();
startTime.set(2016, Calendar.JANUARY, 1);
Calendar endTime = Calendar.getInstance();
List<Filter> filters = new ArrayList<Filter>();
TemporalConstraint temporalConstraint =
new TemporalConstraint(startTime.getTimeInMillis(),
endTime.getTimeInMillis(), AggregationMode.DAILY);
logger.trace("\n\n");
Class<AggregatedServiceUsageRecord> clz =
AggregatedServiceUsageRecord.class;
Map<NumberedFilter, SortedMap<Calendar, Info>> map =
accountingPersistenceQueryCouchDB.getTopValues(clz,
temporalConstraint, filters, "consumerId",
AccountingPersistenceQuery.getDefaultOrderingProperties(clz));
logger.debug("Backend: Top Query Results :\n{}\n", printMap(map));
AccountingPersistenceQuery apq =
AccountingPersistenceQueryFactory.getInstance();
map = apq.getTopValues(clz,
temporalConstraint, filters, "consumerId",
AccountingPersistenceQuery.getDefaultOrderingProperties(clz),
true, 3);
logger.debug("Factory: Top Query Results :\n{}\n", printMap(map));
logger.debug("\n\n\n");
/*
SortedSet<NumberedFilter> possibleValues =
accountingPersistenceQueryCouchDB.getNextPossibleValues(clz,
temporalConstraint, filters, "consumerId",
AccountingPersistenceQuery.getDefaultOrderingProperties(clz));
logger.debug("Backend: Possibile Values :\n{}\n", possibleValues);
possibleValues = apq.getNextPossibleValues(clz,
temporalConstraint, filters, "consumerId",
AccountingPersistenceQuery.getDefaultOrderingProperties(clz));
logger.debug("Factory: Possibile Values :\n{}\n", possibleValues);
logger.debug("\n\n\n");
if(possibleValues.size()>0){
filters.add(possibleValues.first());
}
SortedMap<Calendar, Info> timeSeries =
accountingPersistenceQueryCouchDB.getTimeSeries(clz,
temporalConstraint, filters);
logger.debug("Backend: Time Series for {}:\n{}\n", possibleValues.first(),
printCalendarMap(timeSeries));
timeSeries = apq.getTimeSeries(clz, temporalConstraint, filters);
logger.debug("Factory: Time Series for {}:\n{}\n", possibleValues.first(),
printCalendarMap(timeSeries));
*/
}
@Test
public void testTop2() throws Exception {
Calendar startTime = Calendar.getInstance();
startTime.set(2016, Calendar.JANUARY, 1);
Calendar endTime = Calendar.getInstance();
List<Filter> filters = new ArrayList<Filter>();
Filter filter = new Filter("serviceClass", "VREManagement");
filters.add(filter);
TemporalConstraint temporalConstraint =
new TemporalConstraint(startTime.getTimeInMillis(),
endTime.getTimeInMillis(), AggregationMode.DAILY);
logger.trace("\n\n");
Class<AggregatedServiceUsageRecord> clz =
AggregatedServiceUsageRecord.class;
Map<NumberedFilter, SortedMap<Calendar, Info>> map =
accountingPersistenceQueryCouchDB.getTopValues(clz,
temporalConstraint, filters, "serviceName",
AccountingPersistenceQuery.getDefaultOrderingProperties(clz));
logger.debug("Top Query Results :\n{}", printMap(map));
}
}

52
src/test/java/org/gcube/accounting/analytics/persistence/couchdb/DeleteTestDocument.java
View File

@ -1,52 +0,0 @@
/**
*
*/
package org.gcube.accounting.analytics.persistence.couchdb;
import org.codehaus.jackson.JsonNode;
import org.ektorp.DocumentNotFoundException;
import org.ektorp.ViewQuery;
import org.ektorp.ViewResult;
import org.gcube.accounting.analytics.persistence.AccountingPersistenceBackendQueryConfiguration;
import org.gcube.testutility.ScopedTest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Luca Frosini (ISTI - CNR)
*
*/
public class DeleteTestDocument extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(DeleteTestDocument.class);
//@Test
public void removeTestRecords() throws Exception {
AccountingPersistenceBackendQueryConfiguration persitenceConfiguration = new AccountingPersistenceBackendQueryConfiguration(AccountingPersistenceQueryCouchDB.class);
AccountingPersistenceQueryCouchDB accountingPersistenceQueryCouchDB = new AccountingPersistenceQueryCouchDB();
accountingPersistenceQueryCouchDB.prepareConnection(persitenceConfiguration);
ViewQuery query = new ViewQuery().designDocId("_design/TestRecords");
query = query.viewName("testRecords");
query = query.includeDocs(true);
ViewResult viewResult;
try {
viewResult = accountingPersistenceQueryCouchDB.query(query);
} catch (DocumentNotFoundException e) {
// Install VIEW if valid and does not exist
throw e;
}
for (ViewResult.Row row : viewResult) {
String key = row.getKey();
JsonNode node = row.getValueAsNode();
logger.debug("Going to delete {}", node);
String rev = node.get("_rev").asText();
//accountingPersistenceQueryCouchDB.couchDbConnector.delete(key, rev);
}
}
}

72
src/test/java/org/gcube/accounting/couchdb/query/CouchDBQueryPluginSmartExecutorSchedulerTest.java
View File

@ -1,72 +0,0 @@
/**
*
*/
package org.gcube.accounting.couchdb.query;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.testutility.ScopedTest;
import org.gcube.vremanagement.executor.api.types.LaunchParameter;
import org.gcube.vremanagement.executor.api.types.Scheduling;
import org.gcube.vremanagement.executor.client.plugins.ExecutorPlugin;
import org.gcube.vremanagement.executor.client.proxies.SmartExecutorProxy;
import org.junit.Assert;
import org.junit.Before;
import org.quartz.CronExpression;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Luca Frosini (ISTI - CNR)
*/
public class CouchDBQueryPluginSmartExecutorSchedulerTest extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(CouchDBQueryPluginSmartExecutorSchedulerTest.class);
public static final String START = "START";
public static final String END = "END";
public static final String SCOPE = "";
private SmartExecutorProxy proxy;
@Before
public void before() throws Exception{
ScopeProvider.instance.reset(); // Comment this to run the test. this line has been added to avoid unwanted launch
proxy = ExecutorPlugin.getExecutorProxy(CouchDBQueryPluginDeclaration.NAME).build();
Assert.assertNotNull(proxy);
}
public UUID scheduleTest(Scheduling scheduling, Long sleepTime) throws Exception {
Map<String, Object> inputs = new HashMap<String, Object>();
if(sleepTime==null){
sleepTime = new Long(10*1000); // 10 sec = 10 * 1000 millisec
}
inputs.put(CouchDBQueryPlugin.DELAY_MILLIS, sleepTime);
logger.debug("Inputs : {}", inputs);
LaunchParameter parameter = new LaunchParameter(CouchDBQueryPluginDeclaration.NAME, inputs);
parameter.setScheduling(scheduling);
String uuidString = proxy.launch(parameter);
return UUID.fromString(uuidString);
}
//@Test
public void cronExpPreviousMustBeTerminated() throws Exception {
CronExpression cronExpression = new CronExpression("0 */10 * * * ?"); // every 10 minutes starting from now
Scheduling scheduling = new Scheduling(cronExpression, true);
scheduling.setGlobal(true);
UUID uuid = scheduleTest(scheduling, new Long(1000*60)); // 1 min
logger.debug("Launched with UUID : {}", uuid);
}
//@Test
public void unSchedule() throws Exception {
proxy.unSchedule(null, true);
}
}

35
src/test/java/org/gcube/accounting/couchdb/query/CouchDBQueryPluginTest.java
View File

@ -1,35 +0,0 @@
package org.gcube.accounting.couchdb.query;
import java.util.HashMap;
import java.util.Map;
import org.gcube.accounting.persistence.AccountingPersistenceFactory;
import org.gcube.testutility.ScopedTest;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Luca Frosini (ISTI - CNR)
*/
public class CouchDBQueryPluginTest extends ScopedTest {
/**
* Logger
*/
private static Logger logger = LoggerFactory.getLogger(CouchDBQueryPluginTest.class);
@Test
public void testLaunch() throws Exception {
logger.debug("Starting to test launch()");
AccountingPersistenceFactory.initAccountingPackages();
Map<String, Object> inputs = new HashMap<String, Object>();
inputs.put(CouchDBQueryPlugin.DELAY_MILLIS, 1000*5); // Delay 10 sec
inputs.put(CouchDBQueryPlugin.MAX_RETRY_NUMBER, 0); // No Retry
CouchDBQueryPlugin couchDBQueryPlugin = new CouchDBQueryPlugin(null);
couchDBQueryPlugin.launch(inputs);
logger.debug("-------------- launch() test finished");
}
}

14
src/test/java/org/gcube/accounting/datamodel/usagerecords/TaskUsageRecordScopedTest.java
View File

@ -8,15 +8,11 @@ import java.util.Set;
import org.gcube.accounting.datamodel.UsageRecord; import org.gcube.accounting.datamodel.UsageRecord;
import org.gcube.accounting.datamodel.basetypes.AbstractTaskUsageRecord; import org.gcube.accounting.datamodel.basetypes.AbstractTaskUsageRecord;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.documentstore.exception.InvalidValueException; import org.gcube.documentstore.exception.InvalidValueException;
import org.gcube.documentstore.records.Record; import org.gcube.documentstore.records.Record;
import org.gcube.testutility.ScopedTest; import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUsageRecord; import org.gcube.testutility.TestUsageRecord;
import org.gcube.testutility.TestUtility;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -29,16 +25,6 @@ public class TaskUsageRecordScopedTest extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(TaskUsageRecordScopedTest.class); private static Logger logger = LoggerFactory.getLogger(TaskUsageRecordScopedTest.class);
@Before
public void before() throws Exception{
SecurityTokenProvider.instance.set(TestUtility.TOKEN);
}
@After
public void after() throws Exception{
SecurityTokenProvider.instance.reset();
}
public static Set<String> getExpectedRequiredFields(){ public static Set<String> getExpectedRequiredFields(){
Set<String> expectedRequiredFields = new HashSet<String>(); Set<String> expectedRequiredFields = new HashSet<String>();
expectedRequiredFields.add(Record.ID); expectedRequiredFields.add(Record.ID);

2
src/test/java/org/gcube/accounting/persistence/AccountingPersistenceConfigurationTest.java
View File

@ -143,7 +143,7 @@ public class AccountingPersistenceConfigurationTest extends ScopedTest {
String uri = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.URL_PROPERTY_KEY); String uri = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.URL_PROPERTY_KEY);
String username = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.USERNAME_PROPERTY_KEY); String username = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.USERNAME_PROPERTY_KEY);
String password = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.PASSWORD_PROPERTY_KEY); String password = persitenceConfiguration.getProperty(AccountingPersistenceConfiguration.PASSWORD_PROPERTY_KEY);
logger.debug("{} - {} - {} - {}", TestUtility.getScope(), uri, username, password); logger.debug("{} - {} - {} - {}", ScopedTest.getCurrentContext(), uri, username, password);
}catch(IndexOutOfBoundsException e){ }catch(IndexOutOfBoundsException e){
logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(), e.getMessage()); logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(), e.getMessage());
} catch(Exception e){ } catch(Exception e){

27
src/test/java/org/gcube/accounting/persistence/PersistenceCouchBaseTest.java
View File

@ -7,20 +7,16 @@ import java.io.StringWriter;
import java.util.Calendar; import java.util.Calendar;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resource;
import org.gcube.common.resources.gcore.Resources; import org.gcube.common.resources.gcore.Resources;
import org.gcube.common.resources.gcore.ServiceEndpoint; import org.gcube.common.resources.gcore.ServiceEndpoint;
import org.gcube.documentstore.persistence.PersistenceBackend; import org.gcube.documentstore.persistence.PersistenceBackend;
import org.gcube.documentstore.persistence.PersistenceBackendFactory; import org.gcube.documentstore.persistence.PersistenceBackendFactory;
import org.gcube.documentstore.persistence.PersistenceCouchBase; import org.gcube.documentstore.persistence.PersistenceCouchBase;
//import org.gcube.documentstore.persistence.PersistenceCouchBase;
import org.gcube.informationsystem.publisher.RegistryPublisher; import org.gcube.informationsystem.publisher.RegistryPublisher;
import org.gcube.informationsystem.publisher.RegistryPublisherFactory; import org.gcube.informationsystem.publisher.RegistryPublisherFactory;
import org.gcube.testutility.ScopedTest; import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUtility;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -36,17 +32,6 @@ public class PersistenceCouchBaseTest extends ScopedTest {
public static final TimeUnit timeUnit = TimeUnit.MILLISECONDS; public static final TimeUnit timeUnit = TimeUnit.MILLISECONDS;
public static PersistenceBackend getPersistence(){
PersistenceBackendFactory.setFallbackLocation(null);
return PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope());
}
@Test
public void persistenceIsCouchBase() {
PersistenceBackend persistence = getPersistence();
Assert.assertTrue(persistence instanceof PersistenceCouchBase);
}
private static void publishResource(Resource resource) throws Exception { private static void publishResource(Resource resource) throws Exception {
StringWriter stringWriter = new StringWriter(); StringWriter stringWriter = new StringWriter();
Resources.marshal(resource, stringWriter); Resources.marshal(resource, stringWriter);
@ -54,7 +39,7 @@ public class PersistenceCouchBaseTest extends ScopedTest {
RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); RegistryPublisher registryPublisher = RegistryPublisherFactory.create();
try { try {
logger.debug("Trying to publish to {}:\n{}", TestUtility.getScope(), stringWriter); logger.debug("Trying to publish to {}:\n{}",ScopedTest.getCurrentContext(), stringWriter);
registryPublisher.create(resource); registryPublisher.create(resource);
} catch (Exception e) { } catch (Exception e) {
logger.error("The resource was not published", e); logger.error("The resource was not published", e);
@ -71,7 +56,7 @@ public class PersistenceCouchBaseTest extends ScopedTest {
String id = resource.id(); String id = resource.id();
logger.debug("Trying to remove {} with ID {} from {}", logger.debug("Trying to remove {} with ID {} from {}",
resource.getClass().getSimpleName(), id, resource.getClass().getSimpleName(), id,
TestUtility.getScope()); ScopedTest.getCurrentContext());
registryPublisher.remove(resource); registryPublisher.remove(resource);
@ -88,12 +73,12 @@ public class PersistenceCouchBaseTest extends ScopedTest {
PersistenceCouchBase.class); PersistenceCouchBase.class);
unPublishResource(serviceEndpoint); unPublishResource(serviceEndpoint);
}catch(IndexOutOfBoundsException e){ }catch(IndexOutOfBoundsException e){
SecurityTokenProvider.instance.set(TestUtility.PARENT_TOKEN); ScopedTest.setContext(ALTERNATIVE_TEST_SCOPE);
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceCouchBase.class); AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceCouchBase.class);
serviceEndpoint = persitenceConfiguration.getServiceEndpoint( serviceEndpoint = persitenceConfiguration.getServiceEndpoint(
AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME,
PersistenceCouchBase.class); PersistenceCouchBase.class);
SecurityTokenProvider.instance.set(TestUtility.TOKEN); ScopedTest.setContext(DEFAULT_TEST_SCOPE);
} }
long startTime = Calendar.getInstance().getTimeInMillis(); long startTime = Calendar.getInstance().getTimeInMillis();
@ -103,7 +88,7 @@ public class PersistenceCouchBaseTest extends ScopedTest {
} }
logger.debug("Going to check First Time"); logger.debug("Going to check First Time");
PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first); logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first);
publishResource(serviceEndpoint); publishResource(serviceEndpoint);
@ -115,7 +100,7 @@ public class PersistenceCouchBaseTest extends ScopedTest {
} }
logger.debug("Going to check Second Time"); logger.debug("Going to check Second Time");
PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second); logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second);
Assert.assertNotEquals(first, second); Assert.assertNotEquals(first, second);

7
src/test/java/org/gcube/accounting/persistence/PersistenceCouchDBTest.java
View File

@ -1,6 +1,6 @@
/** /**
* *
*/ *//*
package org.gcube.accounting.persistence; package org.gcube.accounting.persistence;
import java.io.File; import java.io.File;
@ -23,10 +23,10 @@ import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
/** *//**
* @author Luca Frosini (ISTI - CNR) * @author Luca Frosini (ISTI - CNR)
* *
*/ *//*
public class PersistenceCouchDBTest extends ScopedTest { public class PersistenceCouchDBTest extends ScopedTest {
private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchDBTest.class); private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchDBTest.class);
@ -141,3 +141,4 @@ public class PersistenceCouchDBTest extends ScopedTest {
} }
} }
*/

238
src/test/java/org/gcube/accounting/persistence/PersistenceMongoDBTest.java
View File

@ -1,119 +1,119 @@
/** ///**
* // *
*/ // */
package org.gcube.accounting.persistence; //package org.gcube.accounting.persistence;
//
import java.io.StringWriter; //import java.io.StringWriter;
import java.util.Calendar; //import java.util.Calendar;
//
import org.gcube.common.authorization.library.provider.SecurityTokenProvider; //import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.resources.gcore.Resource; //import org.gcube.common.resources.gcore.Resource;
import org.gcube.common.resources.gcore.Resources; //import org.gcube.common.resources.gcore.Resources;
import org.gcube.common.resources.gcore.ServiceEndpoint; //import org.gcube.common.resources.gcore.ServiceEndpoint;
import org.gcube.documentstore.persistence.PersistenceBackend; //import org.gcube.documentstore.persistence.PersistenceBackend;
import org.gcube.documentstore.persistence.PersistenceBackendFactory; //import org.gcube.documentstore.persistence.PersistenceBackendFactory;
import org.gcube.documentstore.persistence.PersistenceMongoDB; //import org.gcube.documentstore.persistence.PersistenceMongoDB;
import org.gcube.informationsystem.publisher.RegistryPublisher; //import org.gcube.informationsystem.publisher.RegistryPublisher;
import org.gcube.informationsystem.publisher.RegistryPublisherFactory; //import org.gcube.informationsystem.publisher.RegistryPublisherFactory;
import org.gcube.testutility.ScopedTest; //import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUtility; //import org.gcube.testutility.TestUtility;
import org.junit.Assert; //import org.junit.Assert;
import org.junit.Test; //import org.junit.Test;
import org.slf4j.Logger; //import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //import org.slf4j.LoggerFactory;
//
/** ///**
* @author Luca Frosini (ISTI - CNR) // * @author Luca Frosini (ISTI - CNR)
* // *
*/ // */
public class PersistenceMongoDBTest extends ScopedTest { //public class PersistenceMongoDBTest extends ScopedTest {
//
private static final Logger logger = LoggerFactory.getLogger(PersistenceMongoDBTest.class); // private static final Logger logger = LoggerFactory.getLogger(PersistenceMongoDBTest.class);
//
public static PersistenceBackend getPersistence(){ // public static PersistenceBackend getPersistence(){
PersistenceBackendFactory.setFallbackLocation(null); // PersistenceBackendFactory.setFallbackLocation(null);
return PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); // return PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope());
} // }
//
@Test // @Test
public void persistenceIsMongoDB() { // public void persistenceIsMongoDB() {
PersistenceBackend accountingPersistence = getPersistence(); // PersistenceBackend accountingPersistence = getPersistence();
Assert.assertTrue(accountingPersistence instanceof PersistenceMongoDB); // Assert.assertTrue(accountingPersistence instanceof PersistenceMongoDB);
} // }
//
private static void publishResource(Resource resource) throws Exception { // private static void publishResource(Resource resource) throws Exception {
StringWriter stringWriter = new StringWriter(); // StringWriter stringWriter = new StringWriter();
Resources.marshal(resource, stringWriter); // Resources.marshal(resource, stringWriter);
//
RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); // RegistryPublisher registryPublisher = RegistryPublisherFactory.create();
//
try { // try {
logger.debug("Trying to publish to {}:\n{}", TestUtility.getScope(), stringWriter); // logger.debug("Trying to publish to {}:\n{}", TestUtility.getScope(), stringWriter);
registryPublisher.create(resource); // registryPublisher.create(resource);
} catch (Exception e) { // } catch (Exception e) {
logger.error("The resource was not published", e); // logger.error("The resource was not published", e);
throw e; // throw e;
} // }
} // }
//
private static void unPublishResource(Resource resource) throws Exception { // private static void unPublishResource(Resource resource) throws Exception {
//StringWriter stringWriter = new StringWriter(); // //StringWriter stringWriter = new StringWriter();
//Resources.marshal(resource, stringWriter); // //Resources.marshal(resource, stringWriter);
//
RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); // RegistryPublisher registryPublisher = RegistryPublisherFactory.create();
//
String id = resource.id(); // String id = resource.id();
logger.debug("Trying to remove {} with ID {} from {}", // logger.debug("Trying to remove {} with ID {} from {}",
resource.getClass().getSimpleName(), id, // resource.getClass().getSimpleName(), id,
TestUtility.getScope()); // TestUtility.getScope());
//
registryPublisher.remove(resource); // registryPublisher.remove(resource);
//
logger.debug("{} with ID {} removed successfully", resource.getClass().getSimpleName(), id); // logger.debug("{} with ID {} removed successfully", resource.getClass().getSimpleName(), id);
} // }
//
public void testScopeRecheck() throws Exception { // public void testScopeRecheck() throws Exception {
ServiceEndpoint serviceEndpoint = null; // ServiceEndpoint serviceEndpoint = null;
try { // try {
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceMongoDB.class); // AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceMongoDB.class);
serviceEndpoint = persitenceConfiguration.getServiceEndpoint( // serviceEndpoint = persitenceConfiguration.getServiceEndpoint(
AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME, // AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME,
PersistenceMongoDB.class); // PersistenceMongoDB.class);
unPublishResource(serviceEndpoint); // unPublishResource(serviceEndpoint);
} catch(IndexOutOfBoundsException e){ // } catch(IndexOutOfBoundsException e){
SecurityTokenProvider.instance.set(TestUtility.PARENT_TOKEN); // SecurityTokenProvider.instance.set(TestUtility.PARENT_TOKEN);
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceMongoDB.class); // AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceMongoDB.class);
serviceEndpoint = persitenceConfiguration.getServiceEndpoint( // serviceEndpoint = persitenceConfiguration.getServiceEndpoint(
AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, // AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY,
AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME, // AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME,
PersistenceMongoDB.class); // PersistenceMongoDB.class);
SecurityTokenProvider.instance.set(TestUtility.TOKEN); // SecurityTokenProvider.instance.set(TestUtility.TOKEN);
} // }
//
//
long startTime = Calendar.getInstance().getTimeInMillis(); // long startTime = Calendar.getInstance().getTimeInMillis();
long endTime = startTime; // long endTime = startTime;
while(endTime <= (startTime + 10*1000)){ // 10 sec // while(endTime <= (startTime + 10*1000)){ // 10 sec
endTime = Calendar.getInstance().getTimeInMillis(); // endTime = Calendar.getInstance().getTimeInMillis();
} // }
//
logger.debug("Going to check First Time"); // logger.debug("Going to check First Time");
PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); // PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope());
logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first); // logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first);
//
publishResource(serviceEndpoint); // publishResource(serviceEndpoint);
//
startTime = Calendar.getInstance().getTimeInMillis(); // startTime = Calendar.getInstance().getTimeInMillis();
endTime = startTime; // endTime = startTime;
while(endTime <= (startTime + (PersistenceBackendFactory.FALLBACK_RETRY_TIME + 100))){ // while(endTime <= (startTime + (PersistenceBackendFactory.FALLBACK_RETRY_TIME + 100))){
endTime = Calendar.getInstance().getTimeInMillis(); // endTime = Calendar.getInstance().getTimeInMillis();
} // }
//
logger.debug("Going to check Second Time"); // logger.debug("Going to check Second Time");
PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); // PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope());
logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second); // logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second);
//
Assert.assertNotEquals(first, second); // Assert.assertNotEquals(first, second);
//
} // }
} //}

7
src/test/java/org/gcube/documentstore/persistence/PersistenceBackendMonitorTest.java
View File

@ -11,7 +11,6 @@ import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.StressTestUtility; import org.gcube.testutility.StressTestUtility;
import org.gcube.testutility.TestOperation; import org.gcube.testutility.TestOperation;
import org.gcube.testutility.TestUsageRecord; import org.gcube.testutility.TestUsageRecord;
import org.gcube.testutility.TestUtility;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -30,7 +29,7 @@ public class PersistenceBackendMonitorTest extends ScopedTest {
@Test @Test
public void parsingTest() throws Exception { public void parsingTest() throws Exception {
PersistenceBackendFactory.setFallbackLocation(null); PersistenceBackendFactory.setFallbackLocation(null);
final PersistenceBackend persistence = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); final PersistenceBackend persistence = PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
StressTestUtility.stressTest(new TestOperation() { StressTestUtility.stressTest(new TestOperation() {
@ -61,7 +60,7 @@ public class PersistenceBackendMonitorTest extends ScopedTest {
persistence.flush(timeout, timeUnit); persistence.flush(timeout, timeUnit);
logger.debug(" END -----------------------------------------------"); logger.debug(" END -----------------------------------------------");
PersistenceBackend persistenceBackend = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); PersistenceBackend persistenceBackend = PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
persistenceBackend.setFallback((FallbackPersistenceBackend) persistenceBackend); persistenceBackend.setFallback((FallbackPersistenceBackend) persistenceBackend);
PersistenceBackendMonitor temporalDataPersistenceBackendMonitor = new PersistenceBackendMonitor(persistenceBackend); PersistenceBackendMonitor temporalDataPersistenceBackendMonitor = new PersistenceBackendMonitor(persistenceBackend);
@ -72,7 +71,7 @@ public class PersistenceBackendMonitorTest extends ScopedTest {
@Test @Test
public void singleParsingTest() throws Exception { public void singleParsingTest() throws Exception {
PersistenceBackendFactory.setFallbackLocation(null); PersistenceBackendFactory.setFallbackLocation(null);
PersistenceBackend persistenceBackend = PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); PersistenceBackend persistenceBackend = PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
//persistenceBackend.setFallback((FallbackPersistenceBackend) persistenceBackend); //persistenceBackend.setFallback((FallbackPersistenceBackend) persistenceBackend);
PersistenceBackendMonitor temporalDataPersistenceBackendMonitor = new PersistenceBackendMonitor(persistenceBackend); PersistenceBackendMonitor temporalDataPersistenceBackendMonitor = new PersistenceBackendMonitor(persistenceBackend);

5
src/test/java/org/gcube/documentstore/persistence/PersistenceBackendTest.java
View File

@ -12,7 +12,6 @@ import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.StressTestUtility; import org.gcube.testutility.StressTestUtility;
import org.gcube.testutility.TestOperation; import org.gcube.testutility.TestOperation;
import org.gcube.testutility.TestUsageRecord; import org.gcube.testutility.TestUsageRecord;
import org.gcube.testutility.TestUtility;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -29,10 +28,10 @@ public class PersistenceBackendTest extends ScopedTest {
public static final long timeout = 5000; public static final long timeout = 5000;
public static final TimeUnit timeUnit = TimeUnit.MILLISECONDS; public static final TimeUnit timeUnit = TimeUnit.MILLISECONDS;
public static PersistenceBackend getPersistence(){ public static PersistenceBackend getPersistence() throws Exception{
AccountingPersistenceFactory.initAccountingPackages(); AccountingPersistenceFactory.initAccountingPackages();
PersistenceBackendFactory.setFallbackLocation(null); PersistenceBackendFactory.setFallbackLocation(null);
return PersistenceBackendFactory.getPersistenceBackend(TestUtility.getScope()); return PersistenceBackendFactory.getPersistenceBackend(ScopedTest.getCurrentContext());
} }
@Test @Test

12
src/test/java/org/gcube/documentstore/persistence/PersistenceCouchBaseTest.java
View File

@ -5,6 +5,7 @@ package org.gcube.documentstore.persistence;
import java.net.URL; import java.net.URL;
import org.gcube.common.authorization.client.exceptions.ObjectNotFound;
import org.gcube.documentstore.records.Record; import org.gcube.documentstore.records.Record;
import org.gcube.testutility.ScopedTest; import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUsageRecord; import org.gcube.testutility.TestUsageRecord;
@ -23,6 +24,17 @@ public class PersistenceCouchBaseTest extends ScopedTest {
private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchBaseTest.class); private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchBaseTest.class);
@Test
public void persistenceIsCouchBase() throws ObjectNotFound, Exception {
PersistenceBackendFactory.setFallbackLocation(null);
FallbackPersistenceBackend fallbackPersistenceBackend = PersistenceBackendFactory.createFallback(ScopedTest.getCurrentContext());
PersistenceBackend persistenceBackend = PersistenceBackendFactory.rediscoverPersistenceBackend(fallbackPersistenceBackend, ScopedTest.getCurrentContext());
Assert.assertTrue(persistenceBackend instanceof PersistenceCouchBase);
}
@Test @Test
public void testJsonNodeUsageRecordConversions() throws Exception { public void testJsonNodeUsageRecordConversions() throws Exception {
Record record = TestUsageRecord.createTestServiceUsageRecord(); Record record = TestUsageRecord.createTestServiceUsageRecord();

144
src/test/java/org/gcube/documentstore/persistence/PersistenceCouchDBTest.java
View File

@ -1,72 +1,72 @@
/** ///**
* // *
*/ // */
package org.gcube.documentstore.persistence; //package org.gcube.documentstore.persistence;
//
import java.net.URL; //import java.net.URL;
//
import org.codehaus.jackson.JsonNode; //import org.codehaus.jackson.JsonNode;
import org.gcube.documentstore.records.Record; //import org.gcube.documentstore.records.Record;
import org.gcube.testutility.ScopedTest; //import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUsageRecord; //import org.gcube.testutility.TestUsageRecord;
import org.junit.Assert; //import org.junit.Assert;
import org.junit.Test; //import org.junit.Test;
import org.slf4j.Logger; //import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //import org.slf4j.LoggerFactory;
//
/** ///**
* @author Luca Frosini (ISTI - CNR) // * @author Luca Frosini (ISTI - CNR)
* // *
*/ // */
public class PersistenceCouchDBTest extends ScopedTest { //public class PersistenceCouchDBTest extends ScopedTest {
//
private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchDBTest.class); // private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchDBTest.class);
//
@Test // @Test
public void testJsonNodeUsageRecordConversions() throws Exception { // public void testJsonNodeUsageRecordConversions() throws Exception {
Record record = TestUsageRecord.createTestServiceUsageRecord(); // Record record = TestUsageRecord.createTestServiceUsageRecord();
logger.debug("UsageRecord : {}", record.toString()); // logger.debug("UsageRecord : {}", record.toString());
JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record); // JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record);
logger.debug("Node : {}", node.toString()); // logger.debug("Node : {}", node.toString());
Record r = PersistenceCouchDB.jsonNodeToUsageRecord(node); // Record r = PersistenceCouchDB.jsonNodeToUsageRecord(node);
Assert.assertEquals(0, record.compareTo(r)); // Assert.assertEquals(0, record.compareTo(r));
Assert.assertEquals(0, r.compareTo(record)); // Assert.assertEquals(0, r.compareTo(record));
} // }
//
@Test // @Test
public void testJsonNodeUsageRecordConversionsWithNestedMap() throws Exception { // public void testJsonNodeUsageRecordConversionsWithNestedMap() throws Exception {
Record record = TestUsageRecord.createTestTaskUsageRecord(); // Record record = TestUsageRecord.createTestTaskUsageRecord();
logger.debug("UsageRecord : {}", record.toString()); // logger.debug("UsageRecord : {}", record.toString());
JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record); // JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record);
logger.debug("Node : {}", node.toString()); // logger.debug("Node : {}", node.toString());
Record r = PersistenceCouchDB.jsonNodeToUsageRecord(node); // Record r = PersistenceCouchDB.jsonNodeToUsageRecord(node);
Assert.assertEquals(0, record.compareTo(r)); // Assert.assertEquals(0, record.compareTo(r));
Assert.assertEquals(0, r.compareTo(record)); // Assert.assertEquals(0, r.compareTo(record));
} // }
//
//@Test // //@Test
public void testProxyWithTestConfiguration() throws Exception{ // public void testProxyWithTestConfiguration() throws Exception{
// Production-Preproduction Nodes // // Production-Preproduction Nodes
//URL url = new URL("http://accounting-d4s.d4science.org"); // //URL url = new URL("http://accounting-d4s.d4science.org");
//URL url = new URL("http://couchdb02-d4s.d4science.org:5984"); // //URL url = new URL("http://couchdb02-d4s.d4science.org:5984");
//URL url = new URL("http://couchdb01-d4s.d4science.org:5984"); // //URL url = new URL("http://couchdb01-d4s.d4science.org:5984");
//
URL url = new URL("http://accounting-d-d4s.d4science.org/_utils/"); // URL url = new URL("http://accounting-d-d4s.d4science.org/_utils/");
//URL url = new URL("http://couchdb02-d-d4s.d4science.org:5984"); // //URL url = new URL("http://couchdb02-d-d4s.d4science.org:5984");
//URL url = new URL("http://couchdb01-d-d4s.d4science.org:5984"); // //URL url = new URL("http://couchdb01-d-d4s.d4science.org:5984");
//
PersistenceBackendConfiguration persitenceConfiguration = PersistenceBackendConfiguration.getUnconfiguredInstance(); // PersistenceBackendConfiguration persitenceConfiguration = PersistenceBackendConfiguration.getUnconfiguredInstance();
persitenceConfiguration.addProperty(PersistenceCouchDB.URL_PROPERTY_KEY, url.toString()); // persitenceConfiguration.addProperty(PersistenceCouchDB.URL_PROPERTY_KEY, url.toString());
persitenceConfiguration.addProperty(PersistenceCouchDB.USERNAME_PROPERTY_KEY, ""); // persitenceConfiguration.addProperty(PersistenceCouchDB.USERNAME_PROPERTY_KEY, "");
persitenceConfiguration.addProperty(PersistenceCouchDB.PASSWORD_PROPERTY_KEY, ""); // persitenceConfiguration.addProperty(PersistenceCouchDB.PASSWORD_PROPERTY_KEY, "");
persitenceConfiguration.addProperty(PersistenceCouchDB.DB_NAME,""); // persitenceConfiguration.addProperty(PersistenceCouchDB.DB_NAME,"");
//
PersistenceCouchDB couch = new PersistenceCouchDB(); // PersistenceCouchDB couch = new PersistenceCouchDB();
couch.prepareConnection(persitenceConfiguration); // couch.prepareConnection(persitenceConfiguration);
//
Record record = TestUsageRecord.createTestServiceUsageRecord(); // Record record = TestUsageRecord.createTestServiceUsageRecord();
couch.reallyAccount(record); // couch.reallyAccount(record);
//
} // }
//
} //}

172
src/test/java/org/gcube/documentstore/persistence/PersistenceMongoDBTest.java
View File

@ -1,86 +1,86 @@
/** ///**
* // *
*/ // */
package org.gcube.documentstore.persistence; //package org.gcube.documentstore.persistence;
//
import java.net.URL; //import java.net.URL;
//
import org.bson.Document; //import org.bson.Document;
import org.gcube.accounting.datamodel.UsageRecord; //import org.gcube.accounting.datamodel.UsageRecord;
import org.gcube.accounting.datamodel.basetypes.AbstractStorageUsageRecord.OperationType; //import org.gcube.accounting.datamodel.basetypes.AbstractStorageUsageRecord.OperationType;
import org.gcube.documentstore.records.Record; //import org.gcube.documentstore.records.Record;
import org.gcube.testutility.TestUsageRecord; //import org.gcube.testutility.TestUsageRecord;
import org.junit.Assert; //import org.junit.Assert;
import org.junit.Test; //import org.junit.Test;
import org.slf4j.Logger; //import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //import org.slf4j.LoggerFactory;
//
/** ///**
* @author Luca Frosini (ISTI - CNR) // * @author Luca Frosini (ISTI - CNR)
* // *
*/ // */
public class PersistenceMongoDBTest { //public class PersistenceMongoDBTest {
//
private static final Logger logger = LoggerFactory.getLogger(PersistenceMongoDBTest.class); // private static final Logger logger = LoggerFactory.getLogger(PersistenceMongoDBTest.class);
//
//
@Test // @Test
public void testJsonNodeUsageRecordConversions() throws Exception { // public void testJsonNodeUsageRecordConversions() throws Exception {
Record record = TestUsageRecord.createTestServiceUsageRecord(); // Record record = TestUsageRecord.createTestServiceUsageRecord();
logger.debug("UsageRecord : {}", record.toString()); // logger.debug("UsageRecord : {}", record.toString());
Document document = PersistenceMongoDB.usageRecordToDocument(record); // Document document = PersistenceMongoDB.usageRecordToDocument(record);
logger.debug("Document : {}", document.toString()); // logger.debug("Document : {}", document.toString());
Record r = PersistenceMongoDB.documentToUsageRecord(document); // Record r = PersistenceMongoDB.documentToUsageRecord(document);
Assert.assertEquals(0, record.compareTo(r)); // Assert.assertEquals(0, record.compareTo(r));
Assert.assertEquals(0, r.compareTo(record)); // Assert.assertEquals(0, r.compareTo(record));
} // }
//
@Test // @Test
public void testJsonNodeUsageRecordConversionsWithNestedMap() throws Exception { // public void testJsonNodeUsageRecordConversionsWithNestedMap() throws Exception {
Record record = TestUsageRecord.createTestTaskUsageRecord(); // Record record = TestUsageRecord.createTestTaskUsageRecord();
logger.debug("UsageRecord : {}", record.toString()); // logger.debug("UsageRecord : {}", record.toString());
Document document = PersistenceMongoDB.usageRecordToDocument(record); // Document document = PersistenceMongoDB.usageRecordToDocument(record);
logger.debug("Document : {}", document.toString()); // logger.debug("Document : {}", document.toString());
Record r = PersistenceMongoDB.documentToUsageRecord(document); // Record r = PersistenceMongoDB.documentToUsageRecord(document);
Assert.assertEquals(0, record.compareTo(r)); // Assert.assertEquals(0, record.compareTo(r));
Assert.assertEquals(0, r.compareTo(record)); // Assert.assertEquals(0, r.compareTo(record));
} // }
//
public enum AUX { // public enum AUX {
TEST, TESTER, TESTING // TEST, TESTER, TESTING
} // }
//
@Test // @Test
public void testConfiguration() throws Exception{ // public void testConfiguration() throws Exception{
URL url = new URL("http://mongo-test.d4science.org"); // URL url = new URL("http://mongo-test.d4science.org");
//
PersistenceBackendConfiguration persitenceConfiguration = PersistenceBackendConfiguration.getUnconfiguredInstance(); // PersistenceBackendConfiguration persitenceConfiguration = PersistenceBackendConfiguration.getUnconfiguredInstance();
persitenceConfiguration.addProperty(PersistenceMongoDB.URL_PROPERTY_KEY, url.toString()); // persitenceConfiguration.addProperty(PersistenceMongoDB.URL_PROPERTY_KEY, url.toString());
persitenceConfiguration.addProperty(PersistenceMongoDB.USERNAME_PROPERTY_KEY, "accounting"); // persitenceConfiguration.addProperty(PersistenceMongoDB.USERNAME_PROPERTY_KEY, "accounting");
persitenceConfiguration.addProperty(PersistenceMongoDB.PASSWORD_PROPERTY_KEY, ""); // persitenceConfiguration.addProperty(PersistenceMongoDB.PASSWORD_PROPERTY_KEY, "");
persitenceConfiguration.addProperty(PersistenceMongoDB.DB_NAME,"accounting"); // persitenceConfiguration.addProperty(PersistenceMongoDB.DB_NAME,"accounting");
persitenceConfiguration.addProperty(PersistenceMongoDB.COLLECTION_NAME, UsageRecord.class.getSimpleName()); // persitenceConfiguration.addProperty(PersistenceMongoDB.COLLECTION_NAME, UsageRecord.class.getSimpleName());
PersistenceMongoDB mongo = new PersistenceMongoDB(); // PersistenceMongoDB mongo = new PersistenceMongoDB();
mongo.prepareConnection(persitenceConfiguration); // mongo.prepareConnection(persitenceConfiguration);
//
//
Record record = TestUsageRecord.createTestServiceUsageRecord(); // Record record = TestUsageRecord.createTestServiceUsageRecord();
record.setResourceProperty("Test", AUX.TESTER); // record.setResourceProperty("Test", AUX.TESTER);
mongo.reallyAccount(record); // mongo.reallyAccount(record);
//
record = TestUsageRecord.createTestStorageUsageRecord(); // record = TestUsageRecord.createTestStorageUsageRecord();
record.setResourceProperty("Test", AUX.TESTER); // record.setResourceProperty("Test", AUX.TESTER);
mongo.reallyAccount(record); // mongo.reallyAccount(record);
//
record = TestUsageRecord.createTestJobUsageRecord(); // record = TestUsageRecord.createTestJobUsageRecord();
mongo.reallyAccount(record); // mongo.reallyAccount(record);
//
} // }
//
@Test // @Test
public void test(){ // public void test(){
EnumCodec<OperationType> enumCodec = new EnumCodec<OperationType>(OperationType.class); // EnumCodec<OperationType> enumCodec = new EnumCodec<OperationType>(OperationType.class);
Assert.assertEquals(OperationType.class, enumCodec.getEncoderClass()); // Assert.assertEquals(OperationType.class, enumCodec.getEncoderClass());
} // }
//
} //}

12
src/test/java/org/gcube/testutility/ScopedTest.java
View File

@ -8,7 +8,6 @@ import java.io.InputStream;
import java.util.Properties; import java.util.Properties;
import org.gcube.common.authorization.client.Constants; import org.gcube.common.authorization.client.Constants;
import org.gcube.common.authorization.client.exceptions.ObjectNotFound;
import org.gcube.common.authorization.library.AuthorizationEntry; import org.gcube.common.authorization.library.AuthorizationEntry;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider; import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.scope.api.ScopeProvider; import org.gcube.common.scope.api.ScopeProvider;
@ -70,7 +69,12 @@ public class ScopedTest {
ALTERNATIVE_TEST_SCOPE = GCUBE_DEVSEC_DEVVRE; ALTERNATIVE_TEST_SCOPE = GCUBE_DEVSEC_DEVVRE;
} }
public static String getCurrentScope(String token) throws ObjectNotFound, Exception{ public static String getCurrentContext() throws Exception{
String token = SecurityTokenProvider.instance.get();
return getCurrentContext(token);
}
public static String getCurrentContext(String token) throws Exception{
AuthorizationEntry authorizationEntry = Constants.authorizationService().get(token); AuthorizationEntry authorizationEntry = Constants.authorizationService().get(token);
String context = authorizationEntry.getContext(); String context = authorizationEntry.getContext();
logger.info("Context of token {} is {}", token, context); logger.info("Context of token {} is {}", token, context);
@ -78,9 +82,9 @@ public class ScopedTest {
} }
public static void setContext(String token) throws ObjectNotFound, Exception{ public static void setContext(String token) throws Exception{
SecurityTokenProvider.instance.set(token); SecurityTokenProvider.instance.set(token);
ScopeProvider.instance.set(getCurrentScope(token)); ScopeProvider.instance.set(getCurrentContext(token));
} }
@BeforeClass @BeforeClass

22
src/test/java/org/gcube/testutility/TestUtility.java
View File

@ -5,12 +5,8 @@ package org.gcube.testutility;
import java.io.StringWriter; import java.io.StringWriter;
import org.gcube.common.authorization.library.AuthorizationEntry;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.authorization.client.Constants;
import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resource;
import org.gcube.common.resources.gcore.Resources; import org.gcube.common.resources.gcore.Resources;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.informationsystem.publisher.RegistryPublisher; import org.gcube.informationsystem.publisher.RegistryPublisher;
import org.gcube.informationsystem.publisher.RegistryPublisherFactory; import org.gcube.informationsystem.publisher.RegistryPublisherFactory;
import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException; import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException;
@ -23,25 +19,11 @@ import org.slf4j.LoggerFactory;
*/ */
public class TestUtility { public class TestUtility {
public static final String TOKEN = "7c66c94c-7f6e-49cd-9a34-909cd3832f3e-98187548";
public static final String PARENT_TOKEN = "";
/** /**
* Logger * Logger
*/ */
private static Logger logger = LoggerFactory.getLogger(TestUtility.class); private static Logger logger = LoggerFactory.getLogger(TestUtility.class);
public static String getScope(){
String token = SecurityTokenProvider.instance.get();
AuthorizationEntry authorizationEntry;
try {
authorizationEntry = Constants.authorizationService().get(token);
} catch (Exception e) {
return ScopeProvider.instance.get();
}
String scope = authorizationEntry.getContext();
return scope;
}
/** /**
* Publish the provided resource on current scope * Publish the provided resource on current scope
@ -56,7 +38,7 @@ public class TestUtility {
RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); RegistryPublisher registryPublisher = RegistryPublisherFactory.create();
try { try {
logger.debug("Trying to publish to {}:\n{}", getScope(), stringWriter); logger.debug("Trying to publish to {}:\n{}", ScopedTest.getCurrentContext(), stringWriter);
registryPublisher.create(resource); registryPublisher.create(resource);
} catch (Exception e) { } catch (Exception e) {
logger.error("The resource was not published", e); logger.error("The resource was not published", e);
@ -77,7 +59,7 @@ public class TestUtility {
RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); RegistryPublisher registryPublisher = RegistryPublisherFactory.create();
String id = resource.id(); String id = resource.id();
logger.debug("Trying to remove {} with ID {} from {}", resource.getClass().getSimpleName(), id, getScope()); logger.debug("Trying to remove {} with ID {} from {}", resource.getClass().getSimpleName(), id, ScopedTest.getCurrentContext());
registryPublisher.remove(resource); registryPublisher.remove(resource);

17
src/test/java/org/gcube/vremanagement/executor/client/QueriedClientTest.java
View File

@ -9,10 +9,9 @@ import java.util.Map;
import org.acme.HelloWorldPlugin; import org.acme.HelloWorldPlugin;
import org.acme.HelloWorldPluginDeclaration; import org.acme.HelloWorldPluginDeclaration;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.clients.ProxyBuilderImpl; import org.gcube.common.clients.ProxyBuilderImpl;
import org.gcube.common.clients.exceptions.DiscoveryException; import org.gcube.common.clients.exceptions.DiscoveryException;
import org.gcube.testutility.TestUtility; import org.gcube.testutility.ScopedTest;
import org.gcube.vremanagement.executor.api.SmartExecutor; import org.gcube.vremanagement.executor.api.SmartExecutor;
import org.gcube.vremanagement.executor.api.types.LaunchParameter; import org.gcube.vremanagement.executor.api.types.LaunchParameter;
import org.gcube.vremanagement.executor.client.plugins.ExecutorPlugin; import org.gcube.vremanagement.executor.client.plugins.ExecutorPlugin;
@ -22,9 +21,7 @@ import org.gcube.vremanagement.executor.client.plugins.query.filter.RandomEndpoi
import org.gcube.vremanagement.executor.client.plugins.query.filter.SpecificEndpointDiscoveryFilter; import org.gcube.vremanagement.executor.client.plugins.query.filter.SpecificEndpointDiscoveryFilter;
import org.gcube.vremanagement.executor.client.proxies.SmartExecutorProxy; import org.gcube.vremanagement.executor.client.proxies.SmartExecutorProxy;
import org.gcube.vremanagement.executor.client.util.Tuple; import org.gcube.vremanagement.executor.client.util.Tuple;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -33,20 +30,10 @@ import org.slf4j.LoggerFactory;
* @author Luca Frosini (ISTI - CNR) * @author Luca Frosini (ISTI - CNR)
* *
*/ */
public class QueriedClientTest { public class QueriedClientTest extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(QueriedClientTest.class); private static Logger logger = LoggerFactory.getLogger(QueriedClientTest.class);
@Before
public void before(){
SecurityTokenProvider.instance.set(TestUtility.TOKEN);
}
@After
public void after(){
SecurityTokenProvider.instance.reset();
}
private void launchTest(SmartExecutorProxy proxy) throws Exception { private void launchTest(SmartExecutorProxy proxy) throws Exception {
Map<String, Object> inputs = new HashMap<String, Object>(); Map<String, Object> inputs = new HashMap<String, Object>();
inputs.put("Hello", "World"); inputs.put("Hello", "World");

18
src/test/java/org/gcube/vremanagement/executor/client/SmartGenericWorkerDiscoveryQuery.java
View File

@ -5,14 +5,11 @@ package org.gcube.vremanagement.executor.client;
import java.util.List; import java.util.List;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider; import org.gcube.testutility.ScopedTest;
import org.gcube.testutility.TestUtility;
//import org.gcube.dataanalysis.executor.plugin.GenericWorkerPluginDeclaration; //import org.gcube.dataanalysis.executor.plugin.GenericWorkerPluginDeclaration;
import org.gcube.vremanagement.executor.client.plugins.ExecutorPlugin; import org.gcube.vremanagement.executor.client.plugins.ExecutorPlugin;
import org.gcube.vremanagement.executor.client.plugins.query.SmartExecutorPluginQuery; import org.gcube.vremanagement.executor.client.plugins.query.SmartExecutorPluginQuery;
import org.gcube.vremanagement.executor.client.plugins.query.filter.ListEndpointDiscoveryFilter; import org.gcube.vremanagement.executor.client.plugins.query.filter.ListEndpointDiscoveryFilter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -21,19 +18,10 @@ import org.slf4j.LoggerFactory;
* @author Luca Frosini (ISTI - CNR) * @author Luca Frosini (ISTI - CNR)
* *
*/ */
public class SmartGenericWorkerDiscoveryQuery { public class SmartGenericWorkerDiscoveryQuery extends ScopedTest {
private static Logger logger = LoggerFactory.getLogger(SmartGenericWorkerDiscoveryQuery.class); private static Logger logger = LoggerFactory.getLogger(SmartGenericWorkerDiscoveryQuery.class);
@Before
public void before(){
SecurityTokenProvider.instance.set(TestUtility.TOKEN);
}
@After
public void after(){
SecurityTokenProvider.instance.reset();
}
@Test @Test
public void testGenericWorkerDiscoveryQuery() throws Exception { public void testGenericWorkerDiscoveryQuery() throws Exception {