org.dashbuilder.dataset.DataSetLookupConstraints.newDataSetLookup java code examples

  public void callback(DataSetMetadata metadata) {
    dataSetLookup = lookupConstraints.newDataSetLookup(metadata);
    updateDataSetLookup();
    changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));
  }
});

  public void callback(DataSetMetadata metadata) {
    dataSetLookup = lookupConstraints.newDataSetLookup(metadata);
    updateDataSetLookup();
    changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));
  }
});

@Test
public void testEmptyConstraints() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(null)
      .setGroupRequired(false);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertThat(result.getColumns().size()).isEqualTo(6);
  assertThat(result.getRowCount()).isEqualTo(50);
}

dataSetLookup = lookupConstraints.newDataSetLookup(dataSetMetadata);
changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));

  @Test
  public void testColumnChanged() {
    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    GroupFunction gf = new GroupFunction("population", "population", AggregateFunctionType.SUM);
    presenter.onColumnFunctionChanged(new GroupFunctionChangedEvent(gf));
    assertEquals(gf.getColumnId(), "population_2");
  }
}

  @Test
  public void testColumnChanged() {
    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    GroupFunction gf = new GroupFunction("population", "population", AggregateFunctionType.SUM);
    presenter.onColumnFunctionChanged(new GroupFunctionChangedEvent(gf));
    assertEquals(gf.getColumnId(), "population_2");
  }
}

@Test
public void testGroupWithLabels() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, LABEL})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][]{
      {"Barcelona", "Engineering"},
      {"Madrid", "Services"},
      {"Brno", "Support"},
      {"Westford", "Engineering"},
      {"Raleigh", "Management"},
      {"London", "Engineering"}
  }, 0);
}

@Test
public void testGroupMultipleColumns() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER, NUMBER, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
       {"Barcelona", "21.00", "2,913.14", "21.00"},
       {"Madrid", "57.00", "2,453.36", "57.00"},
       {"Brno", "153.00", "4,659.24", "153.00"},
       {"Westford", "234.00", "3,594.97", "234.00"},
       {"Raleigh", "481.00", "4,970.78", "481.00"},
       {"London", "329.00", "4,139.77", "329.00"}
   }, 0);
}

@Test
public void testGroupWithOneCalculation() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
      {"Barcelona", "21.00"},
      {"Madrid", "57.00"},
      {"Brno", "153.00"},
      {"Westford", "234.00"},
      {"Raleigh", "481.00"},
      {"London", "329.00"}
  }, 0);
}

@Test
public void testAddColumns() {
  DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
  presenter.init(DATA_2D_MULTIPLE, lookup);
  verify(view).setAddColumnOptionEnabled(true);
  presenter.onAddColumn();
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
  reset(event);
  GroupFunction gf = new GroupFunction("population", "population_2", AggregateFunctionType.SUM);
  presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(gf));
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
}

@Test
public void testAddColumns() {
  DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
  presenter.init(DATA_2D_MULTIPLE, lookup);
  verify(view).setAddColumnOptionEnabled(true);
  presenter.onAddColumn();
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
  reset(event);
  GroupFunction gf = new GroupFunction("population", "population_2", AggregateFunctionType.SUM);
  presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(gf));
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
}

@Test
public void testEmptyConstraints() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(null)
      .setGroupRequired(false);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertThat(result.getColumns().size()).isEqualTo(6);
  assertThat(result.getRowCount()).isEqualTo(50);
}

@Test
public void testMultipleColumns() {
  DataSetLookup lookup = MULTIPLE_COLUMNS.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNull(cg);
  assertEquals(groupOp.getGroupFunctions().size(), MULTIPLE_COLUMNS.getMinColumns());
  for (int i = 0; i < MULTIPLE_COLUMNS.getMinColumns(); i++) {
    GroupFunction gf = groupOp.getGroupFunction(METADATA.getColumnId(i));
    assertNotNull(gf);
    assertEquals(gf.getSourceId(), METADATA.getColumnId(i));
    assertEquals(gf.getColumnId(), METADATA.getColumnId(i));
    assertNull(gf.getFunction());
  }
}

@Test
public void testMultipleColumns() {
  DataSetLookup lookup = MULTIPLE_COLUMNS.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNull(cg);
  assertEquals(groupOp.getGroupFunctions().size(), MULTIPLE_COLUMNS.getMinColumns());
  for (int i = 0; i < MULTIPLE_COLUMNS.getMinColumns(); i++) {
    GroupFunction gf = groupOp.getGroupFunction(METADATA.getColumnId(i));
    assertNotNull(gf);
    assertEquals(gf.getSourceId(), METADATA.getColumnId(i));
    assertEquals(gf.getColumnId(), METADATA.getColumnId(i));
    assertNull(gf.getFunction());
  }
}

@Test
public void testGroupWithLabels() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, LABEL})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][]{
      {"Barcelona", "Engineering"},
      {"Madrid", "Services"},
      {"Brno", "Support"},
      {"Westford", "Engineering"},
      {"Raleigh", "Management"},
      {"London", "Engineering"}
  }, 0);
}

@Test
public void testGroupWithOneCalculation() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
      {"Barcelona", "21.00"},
      {"Madrid", "57.00"},
      {"Brno", "153.00"},
      {"Westford", "234.00"},
      {"Raleigh", "481.00"},
      {"London", "329.00"}
  }, 0);
}

@Test
public void testGroupMultipleColumns() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER, NUMBER, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
       {"Barcelona", "21.00", "2,913.14", "21.00"},
       {"Madrid", "57.00", "2,453.36", "57.00"},
       {"Brno", "153.00", "4,659.24", "153.00"},
       {"Westford", "234.00", "3,594.97", "234.00"},
       {"Raleigh", "481.00", "4,970.78", "481.00"},
       {"London", "329.00", "4,139.77", "329.00"}
   }, 0);
}

@Test
public void testLabelOnlyMetadata() {
  DataSetLookup lookup = lookupConstraints.newDataSetLookup(METADATA2);
  assertEquals(lookup.getDataSetUUID(), "test");

@Test
public void testTwoColumns() {
  DataSetLookup lookup = TWO_COLUMNS_GROUPED.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  assertEquals(groupOp.getGroupFunctions().size(), 2);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNotNull(groupOp);
  assertEquals(cg.getSourceId(), OFFICE);
  assertEquals(cg.getColumnId(), OFFICE);
  assertEquals(cg.getStrategy(), GroupStrategy.DYNAMIC);
  GroupFunction gf1 = groupOp.getGroupFunction(OFFICE);
  assertNotNull(gf1);
  assertNull(gf1.getFunction());
  assertEquals(gf1.getSourceId(), OFFICE);
  assertEquals(gf1.getColumnId(), OFFICE);
  GroupFunction gf2 = groupOp.getGroupFunction(AMOUNT);
  assertNotNull(gf2);
  assertNotNull(gf2.getFunction());
  assertEquals(gf2.getSourceId(), AMOUNT);
  assertEquals(gf2.getColumnId(), AMOUNT);
}
@Test

@Test
public void testTwoColumns() {
  DataSetLookup lookup = TWO_COLUMNS_GROUPED.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  assertEquals(groupOp.getGroupFunctions().size(), 2);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNotNull(groupOp);
  assertEquals(cg.getSourceId(), OFFICE);
  assertEquals(cg.getColumnId(), OFFICE);
  assertEquals(cg.getStrategy(), GroupStrategy.DYNAMIC);
  GroupFunction gf1 = groupOp.getGroupFunction(OFFICE);
  assertNotNull(gf1);
  assertNull(gf1.getFunction());
  assertEquals(gf1.getSourceId(), OFFICE);
  assertEquals(gf1.getColumnId(), OFFICE);
  GroupFunction gf2 = groupOp.getGroupFunction(AMOUNT);
  assertNotNull(gf2);
  assertNotNull(gf2.getFunction());
  assertEquals(gf2.getSourceId(), AMOUNT);
  assertEquals(gf2.getColumnId(), AMOUNT);
}
@Test

Popular methods of DataSetLookupConstraints

Popular in Java

Finding current android device location
setContentView (Activity)
onRequestPermissionsResult (Fragment)
getSupportFragmentManager (FragmentActivity)
Window (java.awt)
A Window object is a top-level window with no borders and no menubar. The default layout for a windo
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
Filter (javax.servlet)
A filter is an object that performs filtering tasks on either the request to a resource (a servlet o
HttpServlet (javax.servlet.http)
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
Reflections (org.reflections)
Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t
Top Sublime Text plugins

How to use newDataSetLookupmethodin org.dashbuilder.dataset.DataSetLookupConstraints

Best Java code snippets using org.dashbuilder.dataset.DataSetLookupConstraints.newDataSetLookup (Showing top 20 results out of 315)

How to use
newDataSetLookup
method
in
org.dashbuilder.dataset.DataSetLookupConstraints