316 lines
12 KiB
Java
316 lines
12 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.informationsystem.resourceregistry.client;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
|
|
import org.gcube.com.fasterxml.jackson.core.JsonProcessingException;
|
|
import org.gcube.informationsystem.base.reference.AccessType;
|
|
import org.gcube.informationsystem.base.reference.Direction;
|
|
import org.gcube.informationsystem.contexts.reference.entities.Context;
|
|
import org.gcube.informationsystem.contexts.reference.relations.IsParentOf;
|
|
import org.gcube.informationsystem.model.impl.properties.MetadataImpl;
|
|
import org.gcube.informationsystem.model.knowledge.ModelKnowledge;
|
|
import org.gcube.informationsystem.model.reference.ModelElement;
|
|
import org.gcube.informationsystem.model.reference.entities.Resource;
|
|
import org.gcube.informationsystem.model.reference.properties.Metadata;
|
|
import org.gcube.informationsystem.model.reference.relations.IsRelatedTo;
|
|
import org.gcube.informationsystem.resourceregistry.api.contexts.ContextCache;
|
|
import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;
|
|
import org.gcube.informationsystem.resourceregistry.api.exceptions.types.SchemaNotFoundException;
|
|
import org.gcube.informationsystem.serialization.ElementMapper;
|
|
import org.gcube.informationsystem.tree.Node;
|
|
import org.gcube.informationsystem.tree.Tree;
|
|
import org.gcube.informationsystem.types.knowledge.TypeInformation;
|
|
import org.gcube.informationsystem.types.reference.Type;
|
|
import org.gcube.informationsystem.utils.UUIDManager;
|
|
import org.gcube.informationsystem.utils.UUIDUtility;
|
|
import org.gcube.resourcemanagement.model.impl.entities.facets.SoftwareFacetImpl;
|
|
import org.gcube.resourcemanagement.model.impl.entities.resources.HostingNodeImpl;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.ContactFacet;
|
|
import org.gcube.resourcemanagement.model.reference.entities.facets.SoftwareFacet;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.EService;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.HostingNode;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.Service;
|
|
import org.gcube.resourcemanagement.model.reference.entities.resources.VirtualService;
|
|
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;
|
|
|
|
/**
|
|
* @author Luca Frosini (ISTI - CNR)
|
|
*/
|
|
public class ResourceRegistryClientTest extends ContextTest {
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(ResourceRegistryClientTest.class);
|
|
|
|
protected ResourceRegistryClient resourceRegistryClient;
|
|
|
|
public ResourceRegistryClientTest() {
|
|
if(ContextTest.RESOURCE_REGISTRY_URL !=null && !ContextTest.RESOURCE_REGISTRY_URL.isEmpty()) {
|
|
resourceRegistryClient = new ResourceRegistryClientImpl(ContextTest.RESOURCE_REGISTRY_URL);
|
|
}else {
|
|
resourceRegistryClient = ResourceRegistryClientFactory.create();
|
|
}
|
|
resourceRegistryClient.setIncludeMeta(true);
|
|
}
|
|
|
|
@Test
|
|
public void testQuery() throws ResourceRegistryException {
|
|
String res = resourceRegistryClient.rawQuery("SELECT FROM V");
|
|
logger.trace(res);
|
|
}
|
|
|
|
protected List<String> getTypeNames(List<Type> types){
|
|
List<String> list = new ArrayList<String>();
|
|
for(Type t : types) {
|
|
list.add(t.getName());
|
|
}
|
|
return list;
|
|
}
|
|
|
|
protected <ME extends ModelElement> void getTypesFromKnowledge(Class<ME> clazz) throws SchemaNotFoundException, ResourceRegistryException {
|
|
List<Type> types = resourceRegistryClient.getType(clazz, true);
|
|
logger.trace("List size {}\n{}", types.size(), getTypeNames(types));
|
|
}
|
|
|
|
@Test
|
|
public void testTypesKnowledgeExpiring() throws Exception {
|
|
resourceRegistryClient.getModelKnowledge();
|
|
resourceRegistryClient.renewModelKnowledge();
|
|
}
|
|
|
|
@Test
|
|
public void testModelKnowledge() throws SchemaNotFoundException, ResourceRegistryException {
|
|
AccessType[] modelTypes = AccessType.getModelTypes();
|
|
for(AccessType accessType : modelTypes) {
|
|
getTypesFromKnowledge(accessType.getTypeClass());
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testGetFacetSchema() throws SchemaNotFoundException, ResourceRegistryException {
|
|
List<Type> types = resourceRegistryClient.getType(ContactFacet.class, true);
|
|
logger.trace("List size {}\n{}", types.size(), getTypeNames(types));
|
|
}
|
|
|
|
@Test
|
|
public void testGetResourceSchema() throws SchemaNotFoundException, ResourceRegistryException {
|
|
List<Type> types = resourceRegistryClient.getType(HostingNode.class, true);
|
|
logger.trace("List size {}\n{}", types.size(), getTypeNames(types));
|
|
types = resourceRegistryClient.getType(VirtualService.class, true);
|
|
logger.trace("List size {}\n{}", types.size(), getTypeNames(types));
|
|
types = resourceRegistryClient.getType(Service.class, true);
|
|
logger.trace("List size {}\n{}", types.size(), getTypeNames(types));
|
|
}
|
|
|
|
@Test
|
|
public void testGetResourceWithLevel() throws SchemaNotFoundException, ResourceRegistryException {
|
|
for(int i=0; i<5; i++) {
|
|
List<Type> types = resourceRegistryClient.getType(Resource.class, i);
|
|
logger.trace("List size with level {} is {}\n{}", i, types.size(), getTypeNames(types));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testGetModelKnowledge() throws SchemaNotFoundException, ResourceRegistryException {
|
|
AccessType[] modelTypes = AccessType.getModelTypes();
|
|
ModelKnowledge<Type, TypeInformation> modelKnowledge = ((ResourceRegistryClientImpl) resourceRegistryClient).getModelKnowledge();
|
|
for(AccessType accessType : modelTypes) {
|
|
Tree<Type> tree = modelKnowledge.getTree(accessType);
|
|
logger.trace("{}", tree);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testGetResourceTree() throws SchemaNotFoundException, ResourceRegistryException {
|
|
Tree<Type> tree = ((ResourceRegistryClientImpl) resourceRegistryClient).getModelKnowledge().getTree(AccessType.RESOURCE);
|
|
logger.trace("{}", tree);
|
|
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testGetNode() throws SchemaNotFoundException, ResourceRegistryException {
|
|
AccessType[] modelTypes = AccessType.getModelTypes();
|
|
for(AccessType accessType : modelTypes) {
|
|
Node<Type> node = resourceRegistryClient.getTypeTreeNode(accessType.getTypeClass());
|
|
logger.trace("{}", node);
|
|
}
|
|
}
|
|
|
|
interface Aux extends Service {
|
|
|
|
}
|
|
|
|
@Test(expected = SchemaNotFoundException.class)
|
|
public void testException() throws SchemaNotFoundException, ResourceRegistryException {
|
|
resourceRegistryClient.getType("Aux", true);
|
|
}
|
|
|
|
/* The following tests are commented because we need to create the instances for tests. this is done in
|
|
* resource registry publisher, which uses client APis to test the publishing as weel as this client.
|
|
*/
|
|
|
|
// @Test
|
|
public void testExists() throws ResourceRegistryException {
|
|
UUID uuid = UUID.fromString("bdaccb35-7f27-45a6-8ca9-11d467cb9233");
|
|
resourceRegistryClient.existInstance(EService.NAME, uuid);
|
|
}
|
|
|
|
// @Test
|
|
public void testExistsByClass() throws Exception {
|
|
UUID uuid = UUIDUtility.fromString("bdaccb35-7f27-45a6-8ca9-11d467cb9233");
|
|
resourceRegistryClient.existInstance(EService.class, uuid);
|
|
}
|
|
|
|
// @Test
|
|
public void testGetInstance() throws Exception {
|
|
UUID uuid = UUIDUtility.fromString("bdaccb35-7f27-45a6-8ca9-11d467cb9233");
|
|
String eService = resourceRegistryClient.getInstance(EService.NAME, uuid);
|
|
logger.trace("{}", eService);
|
|
}
|
|
|
|
// @Test
|
|
public void testGetInstanceByClass() throws Exception {
|
|
UUID uuid = UUIDUtility.fromString("bdaccb35-7f27-45a6-8ca9-11d467cb9233");
|
|
EService eService = resourceRegistryClient.getInstance(EService.class, uuid);
|
|
logger.trace("{}", eService);
|
|
}
|
|
|
|
@Test
|
|
public void testGetInstances() throws ResourceRegistryException {
|
|
String eServices = resourceRegistryClient.getInstances(EService.NAME, true);
|
|
logger.trace("{}", eServices);
|
|
}
|
|
|
|
@Test
|
|
public void testGetInstancesByClass() throws ResourceRegistryException {
|
|
List<EService> eServices = resourceRegistryClient.getInstances(EService.class, true);
|
|
logger.trace("{}", eServices);
|
|
}
|
|
|
|
@Test
|
|
public void testGetRelatedResourcesByClasses() throws ResourceRegistryException {
|
|
List<EService> eServices = resourceRegistryClient.getRelatedResources(EService.class, IsRelatedTo.class,
|
|
Resource.class, Direction.OUT, true);
|
|
logger.trace("{}", eServices);
|
|
}
|
|
|
|
// @Test
|
|
public void testGetRelatedResourcesFromReferenceResourceByClasses() throws Exception {
|
|
UUID uuid = UUIDUtility.fromString("b0d15e45-62af-4221-b785-7d014f10e631");
|
|
HostingNode hostingNode = new HostingNodeImpl();
|
|
hostingNode.setID(uuid);
|
|
Metadata metadata = new MetadataImpl();
|
|
hostingNode.setMetadata(metadata);
|
|
List<EService> eServices = resourceRegistryClient.getRelatedResourcesFromReferenceResource(EService.class,
|
|
IsRelatedTo.class, hostingNode, Direction.OUT, true);
|
|
logger.trace("{}", eServices);
|
|
}
|
|
|
|
@Test
|
|
public void testGetFilteredResourcesByClasses() throws ResourceRegistryException, JsonProcessingException {
|
|
Map<String,String> map = new HashMap<>();
|
|
map.put("group", "VREManagement");
|
|
map.put("name", "SmartExecutor");
|
|
List<EService> eServices = resourceRegistryClient.getFilteredResources(EService.class, IsIdentifiedBy.class,
|
|
SoftwareFacet.class, true, map);
|
|
for(EService eService : eServices) {
|
|
logger.trace("{}", ElementMapper.marshal(eService));
|
|
}
|
|
}
|
|
|
|
|
|
// @Test
|
|
public void testGetResourcesFromReferenceFacet() throws ResourceRegistryException, JsonProcessingException {
|
|
SoftwareFacet softwareFacet = new SoftwareFacetImpl();
|
|
softwareFacet.setID(UUIDManager.getInstance().generateValidUUID());
|
|
Metadata metadata = new MetadataImpl();
|
|
softwareFacet.setMetadata(metadata);
|
|
List<EService> eServices = resourceRegistryClient.getResourcesFromReferenceFacet(EService.class, IsIdentifiedBy.class, softwareFacet, true);
|
|
for(EService eService : eServices) {
|
|
logger.trace("{}", ElementMapper.marshal(eService));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testGetAllContexts() throws Exception {
|
|
List<Context> contexts = resourceRegistryClient.getAllContext();
|
|
logger.debug("{}", contexts);
|
|
|
|
ContextCache contextCache = ContextCache.getInstance();
|
|
Map<UUID, String> uuidToContextFullName = contextCache.getUUIDToContextFullNameAssociation();
|
|
logger.debug("{}", uuidToContextFullName);
|
|
|
|
|
|
for(Context c : contexts) {
|
|
UUID uuid = c.getID();
|
|
if(c.getParent()!=null) {
|
|
IsParentOf isParentOf = c.getParent();
|
|
Context parentContext = isParentOf.getSource();
|
|
UUID parentUUID = parentContext.getID();
|
|
Assert.assertEquals(parentContext, contextCache.getContextByUUID(parentUUID));
|
|
List<IsParentOf> children = parentContext.getChildren();
|
|
boolean found = false;
|
|
for(IsParentOf ipo : children) {
|
|
if(ipo.equals(isParentOf)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
Assert.assertTrue(found);
|
|
logger.debug("{} : {} (parent {} : {})", c.getID(), contextCache.getContextFullNameByUUID(uuid), parentUUID, contextCache.getContextFullNameByUUID(parentUUID));
|
|
}else {
|
|
logger.debug("{} : {}", c.getID(), contextCache.getContextFullNameByUUID(uuid));
|
|
}
|
|
}
|
|
|
|
Context currentContext = resourceRegistryClient.getCurrentContext();
|
|
logger.debug("Current context : {}", currentContext);
|
|
|
|
for(Context c : contexts) {
|
|
UUID uuid = c.getID();
|
|
Context context = resourceRegistryClient.getContext(uuid);
|
|
String fullName = ContextCache.getInstance().getContextFullNameByUUID(uuid);
|
|
logger.debug("{} - {} : {}", uuid, fullName, context);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testParameters() throws Exception {
|
|
resourceRegistryClient.setLimit(1);
|
|
resourceRegistryClient.setIncludeMeta(true);
|
|
List<Context> contexts = ((ResourceRegistryClientImpl) resourceRegistryClient).getAllContextFromServer();
|
|
Assert.assertTrue(contexts.size()==1);
|
|
Assert.assertTrue(contexts.get(0).getMetadata()!=null);
|
|
|
|
resourceRegistryClient.setLimit(1);
|
|
resourceRegistryClient.setIncludeMeta(false);
|
|
contexts = ((ResourceRegistryClientImpl) resourceRegistryClient).getAllContextFromServer();
|
|
Assert.assertTrue(contexts.size()==1);
|
|
Assert.assertTrue(contexts.get(0).getMetadata()==null);
|
|
}
|
|
|
|
|
|
@Test
|
|
public void testRunQueryTemplates() throws Exception {
|
|
String ret = resourceRegistryClient.runQueryTemplate("IS-Monitoring-All-HostingNode");
|
|
logger.trace(ret);
|
|
ret = resourceRegistryClient.runQueryTemplate("IS-Monitoring-All-EService");
|
|
logger.trace(ret);
|
|
ret = resourceRegistryClient.runQueryTemplate("IS-Monitoring-All-HostingNode", "{}");
|
|
logger.trace(ret);
|
|
ret = resourceRegistryClient.runQueryTemplate("IS-Monitoring-All-EService", "{}");
|
|
logger.trace(ret);
|
|
}
|
|
|
|
}
|