/******************************************************************************** | |
* Copyright (c) 2015-2018 Contributors to the Eclipse Foundation | |
* | |
* See the NOTICE file(s) distributed with this work for additional | |
* information regarding copyright ownership. | |
* | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v. 2.0 which is available at | |
* http://www.eclipse.org/legal/epl-2.0. | |
* | |
* SPDX-License-Identifier: EPL-2.0 | |
* | |
********************************************************************************/ | |
package org.eclipse.mdm.query.boundary; | |
import static org.assertj.core.api.Assertions.assertThat; | |
import static org.mockito.Mockito.doThrow; | |
import static org.mockito.Mockito.mock; | |
import static org.mockito.Mockito.when; | |
import java.util.Arrays; | |
import java.util.List; | |
import java.util.Optional; | |
import org.assertj.core.groups.Tuple; | |
import org.eclipse.mdm.api.base.adapter.Attribute; | |
import org.eclipse.mdm.api.base.adapter.EntityType; | |
import org.eclipse.mdm.api.base.adapter.ModelManager; | |
import org.eclipse.mdm.api.base.model.Test; | |
import org.eclipse.mdm.api.base.model.ValueType; | |
import org.eclipse.mdm.api.base.query.DataAccessException; | |
import org.eclipse.mdm.api.base.query.Query; | |
import org.eclipse.mdm.api.base.query.Record; | |
import org.eclipse.mdm.api.base.query.Result; | |
import org.eclipse.mdm.api.base.search.SearchService; | |
import org.eclipse.mdm.api.dflt.ApplicationContext; | |
import org.eclipse.mdm.api.dflt.EntityManager; | |
import org.eclipse.mdm.api.dflt.model.Pool; | |
import org.eclipse.mdm.connector.boundary.ConnectorService; | |
import org.eclipse.mdm.connector.boundary.ConnectorServiceException; | |
import org.eclipse.mdm.query.entity.Column; | |
import org.eclipse.mdm.query.entity.QueryRequest; | |
import org.eclipse.mdm.query.entity.Row; | |
import org.eclipse.mdm.query.entity.SourceFilter; | |
import org.eclipse.mdm.query.entity.SuggestionRequest; | |
import org.mockito.Mockito; | |
public class QueryServiceTest { | |
@org.junit.Test | |
public void testQuery() throws DataAccessException { | |
ApplicationContext context = mockContext(); | |
ConnectorService connectorService = Mockito.mock(ConnectorService.class); | |
when(connectorService.getContextByName("env1")).thenReturn(context); | |
QueryService queryService = new QueryService(); | |
queryService.connectorService = connectorService; | |
SourceFilter filter = new SourceFilter(); | |
filter.setSourceName("env1"); | |
filter.setFilter("Test.Name lk \"*\""); | |
QueryRequest request = new QueryRequest(); | |
request.setResultType("Test"); | |
request.setColumns(Arrays.asList("Test.Id", "Test.Name")); | |
request.setFilters(Arrays.asList(filter)); | |
Row expectedRow = new Row(); | |
expectedRow.setSource("env1"); | |
expectedRow.setType("Test"); | |
expectedRow.setId("id1"); | |
expectedRow.addColumns( | |
Arrays.asList(new Column("Test", "Id", "id1", null), new Column("Test", "Name", "Test-Name", null))); | |
assertThat(queryService.queryRows(request)).contains(expectedRow); | |
} | |
@org.junit.Test | |
public void testQuerySingleQuote() throws DataAccessException { | |
ApplicationContext context = mockContext(); | |
ConnectorService connectorService = Mockito.mock(ConnectorService.class); | |
when(connectorService.getContextByName("env1")).thenReturn(context); | |
QueryService queryService = new QueryService(); | |
queryService.connectorService = connectorService; | |
SourceFilter filter = new SourceFilter(); | |
filter.setSourceName("env1"); | |
filter.setFilter("Test.Name lk '*'"); | |
QueryRequest request = new QueryRequest(); | |
request.setResultType("Test"); | |
request.setColumns(Arrays.asList("Test.Id", "Test.Name")); | |
request.setFilters(Arrays.asList(filter)); | |
Row expectedRow = new Row(); | |
expectedRow.setSource("env1"); | |
expectedRow.setType("Test"); | |
expectedRow.setId("id1"); | |
expectedRow.addColumns( | |
Arrays.asList(new Column("Test", "Id", "id1", null), new Column("Test", "Name", "Test-Name", null))); | |
assertThat(queryService.queryRows(request)).contains(expectedRow); | |
} | |
@org.junit.Test | |
public void testQueryMissingEnvironmentShouldByIgnored() throws DataAccessException { | |
ApplicationContext context = mockContext(); | |
ConnectorService connectorService = Mockito.mock(ConnectorService.class); | |
when(connectorService.getContextByName("env1")).thenReturn(context); | |
doThrow(ConnectorServiceException.class).when(connectorService).getContextByName("env2"); | |
QueryService queryService = new QueryService(); | |
queryService.connectorService = connectorService; | |
SourceFilter filterEnv1 = new SourceFilter(); | |
filterEnv1.setSourceName("env1"); | |
filterEnv1.setFilter("Test.Name lk '*'"); | |
SourceFilter filterEnv2 = new SourceFilter(); | |
filterEnv2.setSourceName("env2"); | |
filterEnv2.setFilter("Test.Name lk '*'"); | |
QueryRequest request = new QueryRequest(); | |
request.setResultType("Test"); | |
request.setColumns(Arrays.asList("Test.Id", "Test.Name", "Pool.Name")); | |
request.setFilters(Arrays.asList(filterEnv1, filterEnv2)); | |
Row expectedRow = new Row(); | |
expectedRow.setSource("env1"); | |
expectedRow.setType("Test"); | |
expectedRow.setId("id1"); | |
expectedRow.addColumns( | |
Arrays.asList(new Column("Test", "Id", "id1", null), new Column("Test", "Name", "Test-Name", null))); | |
assertThat(queryService.queryRows(request)).contains(expectedRow); | |
} | |
@org.junit.Test | |
public void testQueryMissingEntitiesShouldBeIgnored() throws DataAccessException { | |
ApplicationContext context1 = mockContext(); | |
ApplicationContext context2 = mockContext(); | |
ConnectorService connectorService = Mockito.mock(ConnectorService.class); | |
when(connectorService.getContextByName("env1")).thenReturn(context1); | |
when(connectorService.getContextByName("env2")).thenReturn(context2); | |
EntityType type = mockEntity("env2", "Test"); | |
EntityType pool = mockEntity("env2", "Pool"); | |
when(context2.getModelManager().get().getEntityType(Test.class)).thenReturn(type); | |
when(context2.getModelManager().get().getEntityType("Test")).thenReturn(type); | |
when(context2.getModelManager().get().getEntityType(Pool.class)).thenReturn(pool); | |
when(context2.getModelManager().get().getEntityType("Pool")).thenReturn(pool); | |
SearchService ss = mock(SearchService.class); | |
EntityType test = context2.getModelManager().get().getEntityType(Test.class); | |
when(ss.listEntityTypes(Mockito.eq(Test.class))).thenReturn(Arrays.asList(test, pool)); | |
when(ss.listSearchableTypes()).thenReturn(Arrays.asList(Test.class)); | |
Record recordTest = new Record(context2.getModelManager().get().getEntityType(Test.class)); | |
recordTest.addValue(ValueType.STRING.create("Id", "id1")); | |
recordTest.addValue(ValueType.STRING.create("Name", "Test-Name")); | |
Record recordPool = new Record(context2.getModelManager().get().getEntityType(Pool.class)); | |
recordPool.addValue(ValueType.STRING.create("Name", "Pool-Name")); | |
Result result = new Result(); | |
result.addRecord(recordPool); | |
result.addRecord(recordTest); | |
when(context2.getSearchService().get().fetchResults(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) | |
.thenReturn(Arrays.asList(result)); | |
QueryService queryService = new QueryService(); | |
queryService.connectorService = connectorService; | |
SourceFilter filterEnv1 = new SourceFilter(); | |
filterEnv1.setSourceName("env1"); | |
filterEnv1.setFilter("Test.Name lk '*'"); | |
SourceFilter filterEnv2 = new SourceFilter(); | |
filterEnv2.setSourceName("env2"); | |
filterEnv2.setFilter("Test.Name lk '*'"); | |
QueryRequest request = new QueryRequest(); | |
request.setResultType("Test"); | |
request.setColumns(Arrays.asList("Test.Id", "Test.Name", "Pool.Name")); | |
request.setFilters(Arrays.asList(filterEnv1, filterEnv2)); | |
Row expectedRowEnv1 = new Row(); | |
expectedRowEnv1.setSource("env1"); | |
expectedRowEnv1.setType("Test"); | |
expectedRowEnv1.setId("id1"); | |
expectedRowEnv1.addColumns( | |
Arrays.asList(new Column("Test", "Id", "id1", null), new Column("Test", "Name", "Test-Name", null))); | |
Row expectedRowEnv2 = new Row(); | |
expectedRowEnv2.setSource("env2"); | |
expectedRowEnv2.setType("Test"); | |
expectedRowEnv2.setId("id1"); | |
expectedRowEnv2.addColumns(Arrays.asList(new Column("Test", "Id", "id1", null), | |
new Column("Test", "Name", "Test-Name", null), new Column("Pool", "Name", "Pool-Name", null))); | |
List<Row> list = queryService.queryRows(request); | |
assertThat(list).extracting("source", "type", "id").containsOnly(new Tuple("env1", "Test", "id1"), | |
new Tuple("env2", "Test", "id1")); | |
assertThat(list.get(0).getColumns()).containsOnlyElementsOf(expectedRowEnv1.getColumns()); | |
assertThat(list.get(1).getColumns()).containsOnlyElementsOf(expectedRowEnv2.getColumns()); | |
} | |
public static EntityType mockEntity(String sourceName, String name) { | |
Attribute attrId = mock(Attribute.class); | |
when(attrId.getName()).thenReturn("Id"); | |
when(attrId.getValueType()).thenReturn(ValueType.LONG); | |
Attribute attrName = mock(Attribute.class); | |
when(attrName.getName()).thenReturn("Name"); | |
when(attrName.getValueType()).thenReturn(ValueType.STRING); | |
EntityType entity = mock(EntityType.class); | |
when(entity.getSourceName()).thenReturn(sourceName); | |
when(entity.getName()).thenReturn(name); | |
when(entity.getAttributes()).thenReturn(Arrays.asList(attrId, attrName)); | |
when(entity.getAttribute("Name")).thenReturn(attrName); | |
when(entity.getNameAttribute()).thenReturn(attrName); | |
when(entity.getIDAttribute()).thenReturn(attrId); | |
when(attrId.getEntityType()).thenReturn(entity); | |
when(attrName.getEntityType()).thenReturn(entity); | |
return entity; | |
} | |
public static ApplicationContext mockContext() { | |
ModelManager mm = mockModelManager(); | |
EntityManager em = Mockito.mock(EntityManager.class); | |
SearchService ss = mock(SearchService.class); | |
EntityType type = mm.getEntityType(Test.class); | |
when(ss.listEntityTypes(Mockito.eq(Test.class))).thenReturn(Arrays.asList(type)); | |
when(ss.listSearchableTypes()).thenReturn(Arrays.asList(Test.class)); | |
Record record = new Record(mm.getEntityType(Test.class)); | |
record.addValue(ValueType.STRING.create("Id", "id1")); | |
record.addValue(ValueType.STRING.create("Name", "Test-Name")); | |
Result result = new Result(); | |
result.addRecord(record); | |
when(ss.fetchResults(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) | |
.thenReturn(Arrays.asList(result)); | |
ApplicationContext context = Mockito.mock(ApplicationContext.class); | |
when(context.getEntityManager()).thenReturn(Optional.of(em)); | |
when(context.getModelManager()).thenReturn(Optional.of(mm)); | |
when(context.getSearchService()).thenReturn(Optional.of(ss)); | |
return context; | |
} | |
public static ModelManager mockModelManager() { | |
EntityType type = mockEntity("env1", "Test"); | |
ModelManager mm = mock(ModelManager.class); | |
when(mm.getEntityType(Test.class)).thenReturn(type); | |
when(mm.getEntityType("Test")).thenReturn(type); | |
return mm; | |
} | |
@org.junit.Test | |
public void testGetSuggestions() throws Exception { | |
ApplicationContext context = mockContext(); | |
Record record = new Record(context.getModelManager().get().getEntityType(Test.class)); | |
record.addValue(ValueType.LONG.create("Id", 1L)); | |
record.addValue(ValueType.STRING.create("Name", "Test-Name")); | |
Result result = new Result(); | |
result.addRecord(record); | |
Query query = mock(Query.class); | |
when(query.select(Mockito.any(Attribute.class))).thenReturn(query); | |
when(query.group(Mockito.any(Attribute.class))).thenReturn(query); | |
when(query.fetch()).thenReturn(Arrays.asList(result)); | |
org.eclipse.mdm.api.base.query.QueryService qs = mock(org.eclipse.mdm.api.base.query.QueryService.class); | |
when(qs.createQuery()).thenReturn(query); | |
when(context.getQueryService()).thenReturn(Optional.of(qs)); | |
ConnectorService connectorService = Mockito.mock(ConnectorService.class); | |
when(connectorService.getContextByName("env1")).thenReturn(context); | |
QueryService queryService = new QueryService(); | |
queryService.connectorService = connectorService; | |
SuggestionRequest request = new SuggestionRequest(); | |
request.setSourceNames(Arrays.asList("env1")); | |
request.setType("Test"); | |
request.setAttrName("Name"); | |
assertThat(queryService.getSuggestions(request)).contains("Test-Name"); | |
} | |
} |