458 lines
18 KiB
Java
458 lines
18 KiB
Java
package org.gcube.informationsystem.resourceregistry.queries;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
|
|
import org.gcube.common.authorization.client.exceptions.ObjectNotFound;
|
|
import org.gcube.informationsystem.model.reference.entities.Facet;
|
|
import org.gcube.informationsystem.model.reference.entities.Resource;
|
|
import org.gcube.informationsystem.model.reference.relations.ConsistsOf;
|
|
import org.gcube.informationsystem.model.reference.relations.IsRelatedTo;
|
|
import org.gcube.informationsystem.resourceregistry.api.exceptions.queries.InvalidQueryException;
|
|
import org.gcube.informationsystem.resourceregistry.instances.ERManagementTest;
|
|
import org.gcube.informationsystem.resourceregistry.instances.base.ElementManagement;
|
|
import org.gcube.informationsystem.resourceregistry.instances.base.ElementManagementUtility;
|
|
import org.gcube.informationsystem.resourceregistry.instances.model.entities.ResourceManagement;
|
|
import org.gcube.informationsystem.resourceregistry.instances.model.relations.ConsistsOfManagement;
|
|
import org.gcube.informationsystem.resourceregistry.instances.model.relations.IsRelatedToManagement;
|
|
import org.gcube.informationsystem.serialization.ElementMapper;
|
|
import org.gcube.informationsystem.utils.TypeUtility;
|
|
import org.gcube.resourcemanagement.model.impl.entities.facets.IdentifierFacetImpl;
|
|
import org.gcube.resourcemanagement.model.impl.entities.facets.SimplePropertyFacetImpl;
|
|
import org.gcube.resourcemanagement.model.impl.entities.resources.ConfigurationImpl;
|
|
import org.gcube.resourcemanagement.model.impl.relations.consistsof.IsIdentifiedByImpl;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.IdentifierFacet;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.IdentifierFacet.IdentificationType;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.SimplePropertyFacet;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.SoftwareFacet;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.Configuration;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.ConfigurationTemplate;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.EService;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.GCubeResource;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.HostingNode;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.Service;
|
|
import org.gcube.resourcemanagement.model.reference.relations.consistsof.IsIdentifiedBy;
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.arcadedb.graph.Vertex.DIRECTION;
|
|
|
|
/**
|
|
* @author Luca Frosini (ISTI - CNR)
|
|
*/
|
|
public class QueryTest extends ERManagementTest {
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(QueryTest.class);
|
|
|
|
private static final String EXTRA = "EXTRA";
|
|
|
|
@Test
|
|
public void testRawQuery() throws InvalidQueryException {
|
|
QueryImpl queryImpl = new QueryImpl();
|
|
|
|
String query = "select from SoftwareFacet";
|
|
String ret = queryImpl.query(query, false);
|
|
|
|
logger.debug(ret);
|
|
|
|
ret = queryImpl.query(query, false);
|
|
|
|
logger.debug(ret);
|
|
}
|
|
|
|
@Test
|
|
public void testGetAll() throws Exception {
|
|
Map<String, List<Resource>> resources = new HashMap<>();
|
|
|
|
try {
|
|
final int MAX = 5;
|
|
int typeNumber = 0;
|
|
|
|
for (int i = 0; i < MAX; i++) {
|
|
Map<String, Resource> map = createHostingNodeAndEService();
|
|
if (typeNumber == 0) {
|
|
typeNumber = map.size();
|
|
}
|
|
for (String key : map.keySet()) {
|
|
if (!resources.containsKey(key)) {
|
|
resources.put(key, new ArrayList<Resource>());
|
|
}
|
|
resources.get(key).add(map.get(key));
|
|
}
|
|
}
|
|
|
|
/* Getting all instances of created specific Resources */
|
|
for (String key : resources.keySet()) {
|
|
ResourceManagement resourceManagement = (ResourceManagement) ElementManagementUtility.getERManagement(key);
|
|
String json = resourceManagement.all(false);
|
|
|
|
List<Resource> list = ElementMapper.unmarshalList(Resource.class, json);
|
|
logger.debug("{} are {} : {} ", key, list.size(), list);
|
|
Assert.assertTrue(list.size() == MAX);
|
|
}
|
|
|
|
/* Getting all Resources polymorphic and non polymorphic */
|
|
|
|
ResourceManagement resourceManagement = (ResourceManagement) ElementManagementUtility
|
|
.getERManagement(Resource.NAME);
|
|
|
|
String json = resourceManagement.all(true);
|
|
List<Resource> list = ElementMapper.unmarshalList(Resource.class, json);
|
|
logger.debug("{} are {} : {} ", Resource.NAME, list.size(), list);
|
|
Assert.assertTrue(list.size() == (MAX * typeNumber));
|
|
|
|
json = resourceManagement.all(false);
|
|
list = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(list.size() == 0);
|
|
|
|
/* Getting all IsRelatedTo polymorphic and non polymorphic */
|
|
|
|
IsRelatedToManagement isRelatedToManagement = (IsRelatedToManagement) ElementManagementUtility
|
|
.getERManagement(IsRelatedTo.NAME);
|
|
|
|
json = isRelatedToManagement.all(true);
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
List<IsRelatedTo> resourcesList = ElementMapper.unmarshalList(IsRelatedTo.class, json);
|
|
logger.debug("{} are {} : {} ", IsRelatedTo.NAME, resourcesList.size(), resourcesList);
|
|
Assert.assertTrue(resourcesList.size() == MAX);
|
|
|
|
json = isRelatedToManagement.all(false);
|
|
resourcesList = ElementMapper.unmarshalList(IsRelatedTo.class, json);
|
|
Assert.assertTrue(resourcesList.size() == 0);
|
|
|
|
/* Getting all ConsistsOf polymorphic and non polymorphic */
|
|
|
|
ConsistsOfManagement consistsOfManagement = (ConsistsOfManagement) ElementManagementUtility
|
|
.getERManagement(ConsistsOf.NAME);
|
|
|
|
json = consistsOfManagement.all(true);
|
|
@SuppressWarnings("rawtypes")
|
|
List<ConsistsOf> consistsOfPolimorphicList = ElementMapper.unmarshalList(ConsistsOf.class, json);
|
|
logger.debug("{} are {} : {} ", ConsistsOf.NAME, consistsOfPolimorphicList.size(), consistsOfPolimorphicList);
|
|
|
|
json = consistsOfManagement.all(false);
|
|
@SuppressWarnings("rawtypes")
|
|
List<ConsistsOf> consistsOfNonPolimorphicList = ElementMapper.unmarshalList(ConsistsOf.class, json);
|
|
logger.debug("{} are {} : {} ", ConsistsOf.NAME, consistsOfNonPolimorphicList.size(),
|
|
consistsOfNonPolimorphicList);
|
|
|
|
Assert.assertTrue(consistsOfPolimorphicList.size() >= consistsOfNonPolimorphicList.size());
|
|
} finally {
|
|
/* Removing created Entity and Relation to have a clean DB */
|
|
|
|
List<Resource> resourceList = resources.get(HostingNode.NAME);
|
|
for (Resource r : resourceList) {
|
|
deleteResource(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testGetAllFrom() throws Exception {
|
|
Map<String, Resource> map = createHostingNodeAndEService();
|
|
EService eService = (EService) map.get(EService.NAME);
|
|
HostingNode hostingNode = (HostingNode) map.get(HostingNode.NAME);
|
|
|
|
try {
|
|
UUID eServiceUUID = eService.getID();
|
|
UUID hostingNodeUUID = hostingNode.getID();
|
|
|
|
ResourceManagement resourceManagement = new ResourceManagement();
|
|
resourceManagement.setElementType(Service.NAME);
|
|
|
|
/* Getting Hosting Node */
|
|
String json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.BOTH, true,
|
|
null);
|
|
List<Resource> resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 1);
|
|
Resource resource = resourceList.get(0);
|
|
Assert.assertTrue(resource.getID().compareTo(hostingNodeUUID) == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.OUT, true, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 1);
|
|
resource = resourceList.get(0);
|
|
Assert.assertTrue(resource.getID().compareTo(hostingNodeUUID) == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.IN, true, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.BOTH, false, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.OUT, false, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
json = resourceManagement.query(IsRelatedTo.NAME, EService.NAME, eServiceUUID, DIRECTION.IN, false, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
/* END Getting Hosting Node */
|
|
|
|
/* Getting EService */
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.BOTH, true,
|
|
null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 1);
|
|
Assert.assertTrue(resourceList.get(0).getID().compareTo(eServiceUUID) == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.OUT, true, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.IN, true, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 1);
|
|
Assert.assertTrue(resourceList.get(0).getID().compareTo(eServiceUUID) == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.BOTH, false,
|
|
null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.OUT, false,
|
|
null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
|
|
json = resourceManagement.query(IsRelatedTo.NAME, HostingNode.NAME, hostingNodeUUID, DIRECTION.IN, false, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
/* END Getting HostingNode */
|
|
|
|
Facet identificationFacet = eService.getIdentificationFacets().get(0);
|
|
UUID identificationFacetUUID = identificationFacet.getID();
|
|
|
|
/* EService --ConsistsOf--> SoftwareFacet */
|
|
try {
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID,
|
|
DIRECTION.BOTH, true, null);
|
|
} catch (InvalidQueryException e) {
|
|
// Ok expected
|
|
}
|
|
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID, DIRECTION.OUT,
|
|
true, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 1);
|
|
resource = resourceList.get(0);
|
|
Facet targetIdentificationFacet = ((GCubeResource) resource).getIdentificationFacets().get(0);
|
|
Assert.assertTrue(resource.getID().compareTo(eServiceUUID) == 0);
|
|
Assert.assertTrue(targetIdentificationFacet.getID().compareTo(identificationFacetUUID) == 0);
|
|
|
|
try {
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID, DIRECTION.IN,
|
|
true, null);
|
|
throw new Exception("Expected InvalidQueryException");
|
|
} catch (InvalidQueryException e) {
|
|
// Ok expected
|
|
}
|
|
|
|
try {
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID,
|
|
DIRECTION.BOTH, false, null);
|
|
throw new Exception("Expected InvalidQueryException");
|
|
} catch (InvalidQueryException e) {
|
|
// Ok expected
|
|
}
|
|
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID, DIRECTION.OUT,
|
|
false, null);
|
|
resourceList = ElementMapper.unmarshalList(Resource.class, json);
|
|
Assert.assertTrue(resourceList.size() == 0);
|
|
|
|
try {
|
|
json = resourceManagement.query(ConsistsOf.NAME, SoftwareFacet.NAME, identificationFacetUUID, DIRECTION.IN,
|
|
false, null);
|
|
throw new Exception("Expected InvalidQueryException");
|
|
} catch (InvalidQueryException e) {
|
|
// Ok expected
|
|
}
|
|
|
|
/* END EService --ConsistsOf--> SoftwareFacet */
|
|
|
|
} finally {
|
|
deleteResource(eService);
|
|
deleteResource(hostingNode);
|
|
}
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testQuery() throws Exception {
|
|
String relationType = ConsistsOf.NAME;
|
|
String facetType = SoftwareFacet.NAME;
|
|
|
|
Map<String, String> constraint = new HashMap<>();
|
|
constraint.put(SoftwareFacet.GROUP_PROPERTY, "Gis");
|
|
constraint.put(SoftwareFacet.NAME_PROPERTY, "Thredds");
|
|
|
|
String type = Service.NAME;
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
ElementManagement erManagement = ElementManagementUtility.getERManagement(type);
|
|
|
|
if (erManagement instanceof ResourceManagement) {
|
|
boolean[] booleans = new boolean[] {true, false};
|
|
for(boolean bool : booleans) {
|
|
String ret = ((ResourceManagement) erManagement).query(relationType, facetType, null, DIRECTION.OUT, bool, constraint);
|
|
logger.debug("Result of query for {}polymorphic {} --{}--> {} with constaint {} is {}", bool ? "" : "NOT ",
|
|
type, relationType, facetType, constraint, ret);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
protected Configuration createConfiguration(String name, Object value) throws Exception {
|
|
Configuration configuration = new ConfigurationImpl();
|
|
|
|
IdentifierFacet identifierFacet = new IdentifierFacetImpl();
|
|
identifierFacet.setValue(name);
|
|
identifierFacet.setIdentificationType(IdentificationType.STRING);
|
|
if(value!=null) {
|
|
identifierFacet.setAdditionalProperty(EXTRA, value);
|
|
}
|
|
|
|
IsIdentifiedBy<Configuration, IdentifierFacet> isIdentifiedBy = new IsIdentifiedByImpl<Configuration, IdentifierFacet>(configuration, identifierFacet);
|
|
configuration.addFacet(isIdentifiedBy);
|
|
|
|
SimplePropertyFacet simplePropertyFacet = new SimplePropertyFacetImpl();
|
|
simplePropertyFacet.setName("test");
|
|
simplePropertyFacet.setValue("test");
|
|
configuration.addFacet(simplePropertyFacet);
|
|
|
|
return createResource(configuration);
|
|
}
|
|
|
|
|
|
@Test
|
|
public void getAllResourcesHavingFacet() throws ObjectNotFound, Exception {
|
|
String[] names = new String[]{"MyTest", "MyTest", "Aux", "MyID", "MyID"};
|
|
Object[] additionalProperties = new Object[] {5, 5.0, false, "test", null};
|
|
|
|
List<Configuration> createdConfigurations = new ArrayList<>();
|
|
|
|
for(int i=0; i<names.length; i++) {
|
|
createdConfigurations.add(createConfiguration(names[i], additionalProperties[i]));
|
|
}
|
|
|
|
try {
|
|
String parentResourceType = TypeUtility.getTypeName(ConfigurationTemplate.class);
|
|
String resourceType = TypeUtility.getTypeName(Configuration.class);
|
|
String relationType = TypeUtility.getTypeName(IsIdentifiedBy.class);
|
|
String referenceType = TypeUtility.getTypeName(IdentifierFacet.class);
|
|
|
|
ResourceManagement resourceManagement = new ResourceManagement();
|
|
resourceManagement.setElementType(resourceType);
|
|
|
|
ResourceManagement parentResourceManagement = new ResourceManagement();
|
|
parentResourceManagement.setElementType(parentResourceType);
|
|
|
|
|
|
DIRECTION directionEnum = DIRECTION.OUT;
|
|
UUID refereceUUID = null;
|
|
|
|
Boolean[] polymorphics = new Boolean[] {true, false};
|
|
|
|
int expectedSize = 1;
|
|
|
|
Set<UUID> expectedUUIDFor2Results = new HashSet<>();
|
|
expectedUUIDFor2Results.add(createdConfigurations.get(3).getID());
|
|
expectedUUIDFor2Results.add(createdConfigurations.get(4).getID());
|
|
|
|
for(int i=0; i<names.length; i++) {
|
|
|
|
expectedSize = 1;
|
|
if(i==4) {
|
|
expectedSize = 2;
|
|
}
|
|
|
|
Configuration expected = createdConfigurations.get(i);
|
|
UUID expectedUUID = expected.getID();
|
|
|
|
for(Boolean polymorphic : polymorphics) {
|
|
|
|
|
|
Map<String,String> constraint = new HashMap<>();
|
|
constraint.put(IdentifierFacet.VALUE_PROPERTY, names[i]);
|
|
if(additionalProperties[i]!=null) {
|
|
constraint.put(EXTRA, additionalProperties[i].toString());
|
|
}
|
|
|
|
logger.debug("Going to query for {}polymorphic {} --{}--> {} with constaints {}", polymorphic ? "" : "NOT ",
|
|
resourceType, relationType, referenceType, constraint);
|
|
|
|
String ret = resourceManagement.query(relationType, referenceType, refereceUUID, directionEnum,
|
|
polymorphic, constraint);
|
|
|
|
List<Configuration> list = ElementMapper.unmarshalList(Configuration.class, ret);
|
|
Assert.assertTrue(list.size()==expectedSize);
|
|
if(expectedSize==1) {
|
|
Configuration configuration = list.get(0);
|
|
UUID gotUUID = configuration.getID();
|
|
Assert.assertTrue(gotUUID.compareTo(expectedUUID)==0);
|
|
}else {
|
|
Set<UUID> gotUUIDs = new HashSet<>();
|
|
for(Configuration c : list) {
|
|
gotUUIDs.add(c.getID());
|
|
}
|
|
|
|
Assert.assertTrue(gotUUIDs.containsAll(expectedUUIDFor2Results));
|
|
Assert.assertTrue(expectedUUIDFor2Results.containsAll(gotUUIDs));
|
|
|
|
}
|
|
|
|
|
|
if(polymorphic) {
|
|
|
|
logger.debug("Going to query for polymorphic {} --{}--> {} with constaints {}",
|
|
parentResourceType, relationType, referenceType, constraint);
|
|
|
|
String retPolimorphic = parentResourceManagement.query(relationType, referenceType, refereceUUID, directionEnum,
|
|
polymorphic, constraint);
|
|
List<ConfigurationTemplate> listPolimorphic = ElementMapper.unmarshalList(ConfigurationTemplate.class, retPolimorphic);
|
|
Assert.assertTrue(listPolimorphic.size()==expectedSize);
|
|
|
|
if(expectedSize==1) {
|
|
ConfigurationTemplate configurationTemplate = listPolimorphic.get(0);
|
|
Assert.assertTrue(configurationTemplate instanceof Configuration);
|
|
UUID gotPolimorphicUUID = configurationTemplate.getID();
|
|
Assert.assertTrue(gotPolimorphicUUID.compareTo(expectedUUID)==0);
|
|
}else {
|
|
Set<UUID> gotUUIDs = new HashSet<>();
|
|
for(ConfigurationTemplate c : listPolimorphic) {
|
|
Assert.assertTrue(c instanceof Configuration);
|
|
gotUUIDs.add(c.getID());
|
|
}
|
|
|
|
Assert.assertTrue(gotUUIDs.containsAll(expectedUUIDFor2Results));
|
|
Assert.assertTrue(expectedUUIDFor2Results.containsAll(gotUUIDs));
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
} finally {
|
|
for(Configuration configuration : createdConfigurations) {
|
|
deleteResource(configuration);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|