From 7b1f28a52fc3a9fbd4ea3c49ab3e7780a5c3728b Mon Sep 17 00:00:00 2001 From: Luca Frosini Date: Wed, 10 Feb 2016 09:51:49 +0000 Subject: [PATCH] refs #2209: Remove the use of ScopeProvider if any from document-store-lib-couchdb https://support.d4science.org/issues/2209 git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/data-publishing/document-store-lib-couchdb@124029 82a268e6-3cf1-43bd-a215-b396298e98cf --- pom.xml | 8 +- .../persistence/PersistenceCouchDBTest.java | 70 ++++++++------- .../accounting/persistence/TestUtility.java | 86 +++++++++++++++++++ .../persistence/PersistenceCouchBaseTest.java | 19 +++- 4 files changed, 145 insertions(+), 38 deletions(-) create mode 100644 src/test/java/org/gcube/accounting/persistence/TestUtility.java diff --git a/pom.xml b/pom.xml index 38ee520..0f39725 100644 --- a/pom.xml +++ b/pom.xml @@ -8,7 +8,7 @@ org.gcube.data.publishing document-store-lib-couchdb - 1.0.0-SNAPSHOT + 1.1.0-SNAPSHOT Document Store CouchDB Document Store CouchDB Implementation @@ -44,19 +44,19 @@ org.gcube.accounting accounting-lib - [2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT) + [2.1.0-SNAPSHOT, 3.0.0-SNAPSHOT) test org.gcube.core common-encryption - [1.0.2-SNAPSHOT, 2.0.0-SNAPSHOT) + [1.0.0-SNAPSHOT, 3.0.0-SNAPSHOT) test org.gcube.resources registry-publisher - [1.0.0-SNAPSHOT,2.0.0-SNAPSHOT) + [1.0.0-SNAPSHOT,3.0.0-SNAPSHOT) test diff --git a/src/test/java/org/gcube/accounting/persistence/PersistenceCouchDBTest.java b/src/test/java/org/gcube/accounting/persistence/PersistenceCouchDBTest.java index 4a26213..7a33449 100644 --- a/src/test/java/org/gcube/accounting/persistence/PersistenceCouchDBTest.java +++ b/src/test/java/org/gcube/accounting/persistence/PersistenceCouchDBTest.java @@ -4,21 +4,21 @@ package org.gcube.accounting.persistence; import java.io.StringWriter; -import java.util.ArrayList; import java.util.Calendar; -import java.util.List; +import org.gcube.accounting.datamodel.BasicUsageRecord; +import org.gcube.common.authorization.library.provider.SecurityTokenProvider; import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resources; import org.gcube.common.resources.gcore.ServiceEndpoint; -import org.gcube.common.scope.api.ScopeProvider; import org.gcube.documentstore.persistence.PersistenceBackend; import org.gcube.documentstore.persistence.PersistenceBackendFactory; import org.gcube.documentstore.persistence.PersistenceCouchDB; +import org.gcube.informationsystem.publisher.RegistryPublisher; import org.gcube.informationsystem.publisher.RegistryPublisherFactory; -import org.gcube.informationsystem.publisher.ScopedPublisher; -import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException; +import org.junit.After; import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -31,10 +31,19 @@ public class PersistenceCouchDBTest { private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchDBTest.class); + @Before + public void before() throws Exception{ + SecurityTokenProvider.instance.set(TestUtility.TOKEN); + } + + @After + public void after(){ + SecurityTokenProvider.instance.reset(); + } + public static PersistenceBackend getPersistence(){ - ScopeProvider.instance.set("/gcube/devNext"); PersistenceBackendFactory.setFallbackLocation(null); - return PersistenceBackendFactory.getPersistenceBackend(ScopeProvider.instance.get()); + return PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken()); } @Test @@ -43,33 +52,38 @@ public class PersistenceCouchDBTest { Assert.assertTrue(persistence instanceof PersistenceCouchDB); } - private static void publishScopedResource(Resource resource, List scopes) throws Exception { + private static void publishResource(Resource resource) throws Exception { StringWriter stringWriter = new StringWriter(); Resources.marshal(resource, stringWriter); - ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher(); + RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); + try { - logger.debug("Trying to publish to {}:\n{}", scopes, stringWriter); - scopedPublisher.create(resource, scopes); + logger.debug("Trying to publish to {}:\n{}", BasicUsageRecord.getScopeFromToken(), stringWriter); + registryPublisher.create(resource); } catch (Exception e) { logger.error("The resource was not published", e); throw e; } } - private static void unPublishScopedResource(Resource resource, List scopes) throws RegistryNotFoundException, Exception { - ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher(); - String id = resource.id(); - logger.debug("Trying to remove {} with ID {} from {}", resource.getClass().getSimpleName(), id, scopes); - scopedPublisher.remove(resource, scopes); + private static void unPublishResource(Resource resource) throws Exception { + //StringWriter stringWriter = new StringWriter(); + //Resources.marshal(resource, stringWriter); + + RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); + + String id = resource.id(); + logger.debug("Trying to remove {} with ID {} from {}", + resource.getClass().getSimpleName(), id, + BasicUsageRecord.getScopeFromToken()); + + registryPublisher.remove(resource); + logger.debug("{} with ID {} removed successfully", resource.getClass().getSimpleName(), id); } public void testScopeRecheck() throws Exception { - final String vreScopeToUse = "/gcube/devsec/LucioVRE"; - final String parentVREScopeToUse = "/gcube/devsec"; - - ScopeProvider.instance.set(vreScopeToUse); ServiceEndpoint serviceEndpoint = null; try { @@ -79,18 +93,16 @@ public class PersistenceCouchDBTest { AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME, PersistenceCouchDB.class); - List scopes = new ArrayList(); - scopes.add(ScopeProvider.instance.get()); - unPublishScopedResource(serviceEndpoint, scopes); + unPublishResource(serviceEndpoint); } catch(IndexOutOfBoundsException e){ - ScopeProvider.instance.set(parentVREScopeToUse); + SecurityTokenProvider.instance.set(TestUtility.PARENT_TOKEN); AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(PersistenceCouchDB.class); serviceEndpoint = persitenceConfiguration.getServiceEndpoint( AccountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY, AccountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME, PersistenceCouchDB.class); - ScopeProvider.instance.set(vreScopeToUse); + SecurityTokenProvider.instance.set(TestUtility.TOKEN); } @@ -101,12 +113,10 @@ public class PersistenceCouchDBTest { } logger.debug("Going to check First Time"); - PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(ScopeProvider.instance.get()); + PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken()); logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first); - List scopes = new ArrayList(); - scopes.add(ScopeProvider.instance.get()); - publishScopedResource(serviceEndpoint, scopes); + publishResource(serviceEndpoint); startTime = Calendar.getInstance().getTimeInMillis(); endTime = startTime; @@ -115,7 +125,7 @@ public class PersistenceCouchDBTest { } logger.debug("Going to check Second Time"); - PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(ScopeProvider.instance.get()); + PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken()); logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second); Assert.assertNotEquals(first, second); diff --git a/src/test/java/org/gcube/accounting/persistence/TestUtility.java b/src/test/java/org/gcube/accounting/persistence/TestUtility.java new file mode 100644 index 0000000..6f5fbee --- /dev/null +++ b/src/test/java/org/gcube/accounting/persistence/TestUtility.java @@ -0,0 +1,86 @@ +/** + * + */ +package org.gcube.accounting.persistence; + +import java.io.StringWriter; + +import org.gcube.common.authorization.client.Constants; +import org.gcube.common.authorization.library.AuthorizationEntry; +import org.gcube.common.authorization.library.provider.SecurityTokenProvider; +import org.gcube.common.resources.gcore.Resource; +import org.gcube.common.resources.gcore.Resources; +import org.gcube.informationsystem.publisher.RegistryPublisher; +import org.gcube.informationsystem.publisher.RegistryPublisherFactory; +import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * @author Luca Frosini (ISTI - CNR) http://www.lucafrosini.com/ + * + */ +public class TestUtility { + + public static final String TOKEN = ""; + public static final String PARENT_TOKEN = ""; + + /** + * Logger + */ + private static Logger logger = LoggerFactory.getLogger(TestUtility.class); + + public static String getScopeFromToken(){ + String token = SecurityTokenProvider.instance.get(); + AuthorizationEntry authorizationEntry; + try { + authorizationEntry = Constants.authorizationService().get(token); + } catch (Exception e) { + throw new RuntimeException(e); + } + String scope = authorizationEntry.getContext(); + return scope; + } + + /** + * Publish the provided resource on current scope + * @param resource to be published + * @throws RegistryNotFoundException if the Registry is not found so the + * resource has not be published + */ + public static void publishResource(Resource resource) throws Exception { + StringWriter stringWriter = new StringWriter(); + Resources.marshal(resource, stringWriter); + + RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); + + try { + logger.debug("Trying to publish to {}:\n{}", getScopeFromToken(), stringWriter); + registryPublisher.create(resource); + } catch (Exception e) { + logger.error("The resource was not published", e); + throw e; + } + } + + /** + * Remove the resource from IS from curretn scope + * @param resource to be unpublished + * @throws RegistryNotFoundException if the Registry is not found so the + * resource has not be published + */ + public static void unPublishResource(Resource resource) throws Exception { + //StringWriter stringWriter = new StringWriter(); + //Resources.marshal(resource, stringWriter); + + RegistryPublisher registryPublisher = RegistryPublisherFactory.create(); + + String id = resource.id(); + logger.debug("Trying to remove {} with ID {} from {}", resource.getClass().getSimpleName(), id, getScopeFromToken()); + + registryPublisher.remove(resource); + + logger.debug("{} with ID {} removed successfully", resource.getClass().getSimpleName(), id); + } + +} diff --git a/src/test/java/org/gcube/documentstore/persistence/PersistenceCouchBaseTest.java b/src/test/java/org/gcube/documentstore/persistence/PersistenceCouchBaseTest.java index 5588705..26a0cef 100644 --- a/src/test/java/org/gcube/documentstore/persistence/PersistenceCouchBaseTest.java +++ b/src/test/java/org/gcube/documentstore/persistence/PersistenceCouchBaseTest.java @@ -7,9 +7,12 @@ import java.net.URL; import org.codehaus.jackson.JsonNode; import org.gcube.accounting.datamodel.basetypes.TestUsageRecord; -import org.gcube.common.scope.api.ScopeProvider; +import org.gcube.accounting.persistence.TestUtility; +import org.gcube.common.authorization.library.provider.SecurityTokenProvider; import org.gcube.documentstore.records.Record; +import org.junit.After; import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -22,9 +25,18 @@ public class PersistenceCouchBaseTest { private static final Logger logger = LoggerFactory.getLogger(PersistenceCouchBaseTest.class); + @Before + public void before() throws Exception { + SecurityTokenProvider.instance.set(TestUtility.TOKEN); + } + + @After + public void after(){ + SecurityTokenProvider.instance.reset(); + } + @Test public void testJsonNodeUsageRecordConversions() throws Exception { - ScopeProvider.instance.set("/gcube/devNext"); Record record = TestUsageRecord.createTestServiceUsageRecordAutomaticScope(); logger.debug("UsageRecord : {}", record.toString()); JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record); @@ -36,7 +48,6 @@ public class PersistenceCouchBaseTest { @Test public void testJsonNodeUsageRecordConversionsWithNestedMap() throws Exception { - ScopeProvider.instance.set("/gcube/devNext"); Record record = TestUsageRecord.createTestTaskUsageRecordAutomaticScope(); logger.debug("UsageRecord : {}", record.toString()); JsonNode node = PersistenceCouchDB.usageRecordToJsonNode(record); @@ -46,6 +57,7 @@ public class PersistenceCouchBaseTest { Assert.assertEquals(0, r.compareTo(record)); } + //@Test public void testProxyWithTestConfiguration() throws Exception{ // Production-Preproduction Nodes //URL url = new URL("http://accounting-d4s.d4science.org"); @@ -65,7 +77,6 @@ public class PersistenceCouchBaseTest { PersistenceCouchDB couch = new PersistenceCouchDB(); couch.prepareConnection(persitenceConfiguration); - ScopeProvider.instance.set("/gcube/devNext"); Record record = TestUsageRecord.createTestServiceUsageRecordAutomaticScope(); couch.reallyAccount(record);