@Test
public void testGetCategory() {
String columnId = "my_test_column_id";
LogicalModel logicalModel = mock(LogicalModel.class);
doReturn(Collections.<Category>emptyList()).when(logicalModel).getCategories();
Category result = spyMetadataServiceUtil.getCategory(columnId, logicalModel);
assertNull(result);
LogicalColumn mockColumn = mock(LogicalColumn.class);
Category mockCat1 = mock(Category.class);
Category mockCat2 = mock(Category.class);
doReturn(null).when(mockCat1).findLogicalColumn(columnId);
doReturn(mockColumn).when(mockCat2).findLogicalColumn(columnId);
List<Category> listCategories = new ArrayList<Category>(2);
listCategories.add(mockCat1);
listCategories.add(mockCat2);
doReturn(listCategories).when(logicalModel).getCategories();
result = spyMetadataServiceUtil.getCategory(columnId, logicalModel);
assertEquals(mockCat2, result);
}
@Test
public void testCreateCdaJson() throws JSONException {
String result = spyMetadataServiceUtil.createCdaJson(null, DEFAULT_LOCALE);
assertNull(result);
Object[][] headers = new Object[][] {{new String("Header_0"), new String("Header_1")}};
IPentahoMetaData mockMetaData = mock(IPentahoMetaData.class);
doReturn(headers).when(mockMetaData).getColumnHeaders();
doReturn(DataType.STRING)
.when(mockMetaData)
.getAttribute(0, 0, IPhysicalColumn.DATATYPE_PROPERTY);
doReturn(DataType.BOOLEAN)
.when(mockMetaData)
.getAttribute(0, 1, IPhysicalColumn.DATATYPE_PROPERTY);
doReturn(new LocalizedString(DEFAULT_LOCALE, "name_0"))
.when(mockMetaData)
.getAttribute(0, 0, Concept.NAME_PROPERTY);
doReturn(new LocalizedString(DEFAULT_LOCALE, "name_1"))
.when(mockMetaData)
.getAttribute(0, 1, Concept.NAME_PROPERTY);
IPentahoResultSet mockResultSet = mock(IPentahoResultSet.class);
doReturn(2).when(mockResultSet).getColumnCount();
doReturn(2).when(mockResultSet).getRowCount();
doReturn("val_00").when(mockResultSet).getValueAt(0, 0);
doReturn("val_01").when(mockResultSet).getValueAt(0, 1);
doReturn("val_10").when(mockResultSet).getValueAt(1, 0);
doReturn("val_11").when(mockResultSet).getValueAt(1, 1);
doReturn(mockMetaData).when(mockResultSet).getMetaData();
result = spyMetadataServiceUtil.createCdaJson(mockResultSet, DEFAULT_LOCALE);
assertNotNull(result);
JSONObject resultObj = new JSONObject(result);
assertTrue(resultObj.has("metadata"));
assertTrue(resultObj.has("resultset"));
JSONArray resultset = resultObj.getJSONArray("resultset");
assertEquals("[[\"val_00\",\"val_01\"],[\"val_10\",\"val_11\"]]", resultset.toString());
JSONArray metadata = resultObj.getJSONArray("metadata");
makeMetadataObjectAssertions(metadata.getJSONObject(0), 0, "STRING");
makeMetadataObjectAssertions(metadata.getJSONObject(1), 1, "BOOLEAN");
}
@Test
public void testConvertQuery() {
String domainName = "test_domain";
String modelId = "model_id";
String columnId = "column_id";
LogicalColumn mockColumn = mock(LogicalColumn.class);
doReturn(DataType.STRING).when(mockColumn).getDataType();
doReturn(columnId).when(mockColumn).getId();
LogicalModel mockModel = mock(LogicalModel.class);
doReturn(mockColumn).when(mockModel).findLogicalColumn(columnId);
Domain mockDomain = mock(Domain.class);
doReturn(mockModel).when(mockDomain).findLogicalModel(modelId);
IMetadataDomainRepository mockRepo = mock(IMetadataDomainRepository.class);
doReturn(mockDomain).when(mockRepo).getDomain(domainName);
org.pentaho.metadata.model.Category category = mock(org.pentaho.metadata.model.Category.class);
doReturn(category).when(spyMetadataServiceUtil).getCategory(columnId, mockModel);
doReturn(mockRepo).when(spyMetadataServiceUtil).getDomainRepository();
Query srcQuery = createMockQuery(domainName, modelId, columnId);
ModelInfo info = new ModelInfo();
info.setGroupId(domainName);
info.setModelId(modelId);
org.pentaho.metadata.query.model.Query result =
spyMetadataServiceUtil.convertQuery(srcQuery, info);
assertNotNull(result);
assertEquals(mockDomain, result.getDomain());
assertFalse(result.getDisableDistinct());
assertEquals(mockModel, result.getLogicalModel());
assertEquals(1, result.getSelections().size());
Selection selection = result.getSelections().get(0);
assertEquals(mockColumn, selection.getLogicalColumn());
assertEquals(category, selection.getCategory());
assertEquals(AggregationType.SUM, selection.getActiveAggregationType());
assertEquals(AggregationType.SUM, selection.getAggregationType());
assertEquals(1, result.getConstraints().size());
Constraint constraint = result.getConstraints().get(0);
assertEquals(CombinationType.AND, constraint.getCombinationType());
assertNull(constraint.getFormula());
assertEquals(1, result.getOrders().size());
org.pentaho.metadata.query.model.Order resOrder = result.getOrders().get(0);
assertEquals(selection, resOrder.getSelection());
assertEquals(Type.ASC, resOrder.getType());
assertEquals(1, result.getParameters().size());
org.pentaho.metadata.query.model.Parameter param = result.getParameters().get(0);
assertEquals("parameter_name", param.getName());
assertEquals("val_0", param.getDefaultValue());
assertEquals(DataType.STRING, param.getType());
}
@Test
public void testDeserializeJsonQuery() {
String json =
"{\"class\":\"org.pentaho.metadata.model.thin.Query\",\"conditions\":[{\"class\":\"org.pentaho.metadata.model.thin.Condition\","
+ "\"combinationType\":\"AND\",\"elementId\":\"MY_ELEM_ID\",\"operator\":\"EQUAL\",\"parameterized\":false,"
+ "\"parentId\":\"MY_PARENT_ID\",\"selectedAggregation\":\"SUM\",\"value\":[\"Val_0\"]}],\"defaultParameterMap\":null,"
+ "\"disableDistinct\":false,\"elements\":[{\"availableAggregations\":null,\"capabilities\":{},"
+ "\"class\":\"org.pentaho.metadata.model.thin.Element\",\"dataType\":null,\"defaultAggregation\":\"NONE\","
+ "\"description\":null,\"elementType\":null,\"formatMask\":null,\"hiddenForUser\":false,\"horizontalAlignment\":\"LEFT\","
+ "\"id\":\"MY_ELEM_ID\",\"isQueryElement\":true,\"name\":null,\"parentId\":\"PARENT_ID\",\"selectedAggregation\":\"SUM\"}],"
+ "\"orders\":[{\"class\":\"org.pentaho.metadata.model.thin.Order\",\"elementId\":\"MY_ELEM_ID\",\"orderType\":\"ASC\","
+ "\"parentId\":\"MY_PARENT_ID\"}],\"parameters\":[],\"sourceId\":\"MY_DOMAIN_ID\"}";
Query result = spyMetadataServiceUtil.deserializeJsonQuery(json);
assertNotNull(result);
assertEquals("MY_DOMAIN_ID", result.getSourceId());
assertFalse(result.getDisableDistinct());
assertEquals(1, result.getElements().length);
Element column = result.getElements()[0];
assertEquals("MY_ELEM_ID", column.getId());
assertNull(column.getName());
assertNull(column.getDescription());
assertNull(column.getElementType());
assertNull(column.getFormatMask());
assertNull(column.getDataType());
assertFalse(column.isHiddenForUser());
assertEquals("NONE", column.getDefaultAggregation());
assertEquals("PARENT_ID", column.getParentId());
assertEquals("LEFT", column.getHorizontalAlignment());
assertEquals("SUM", column.getSelectedAggregation());
assertEquals(1, result.getConditions().length);
Condition condition = result.getConditions()[0];
assertEquals("MY_PARENT_ID", condition.getParentId());
assertEquals("MY_ELEM_ID", condition.getElementId());
assertEquals("AND", condition.getCombinationType());
assertEquals("EQUAL", condition.getOperator());
assertFalse(condition.isParameterized());
assertEquals("SUM", condition.getSelectedAggregation());
Assert.assertArrayEquals(new String[] {"Val_0"}, condition.getValue());
assertEquals(1, result.getOrders().length);
Order order = result.getOrders()[0];
assertEquals("MY_ELEM_ID", order.getElementId());
assertEquals("MY_PARENT_ID", order.getParentId());
assertEquals("ASC", order.getOrderType());
assertEquals(0, result.getParameters().length);
}
@Test
public void testCreateThinModel() {
LogicalColumn column =
createMockColumn(
"id_column", "name_column", "description_column", DataType.STRING, FieldType.ATTRIBUTE);
List<LogicalColumn> listColumns = new ArrayList<LogicalColumn>(1);
listColumns.add(column);
Category category =
createMockCategory("id_category", "name_category", "description_category", listColumns);
List<Category> listCategories = new ArrayList<Category>(1);
listCategories.add(category);
LogicalModel lmodel = createMockModel("id", "name", "description", listCategories);
Model model = spyMetadataServiceUtil.createThinModel(lmodel, DOMAIN_ID);
assertModels(lmodel, model, DOMAIN_ID);
assertEquals(2, model.getElements().length);
Element elemCat = model.getElements()[0];
assertElements(category, elemCat);
Element elemCol = model.getElements()[1];
assertColumns(column, elemCol, category.getId());
}
