How to use

check

method

in

org.dashbuilder.dataset.DataSetLookupConstraints

public ValidationError check(DataSetLookup lookup) {
  return check(lookup, null);
}

public ValidationError check(DataSetLookup lookup) {
  return check(lookup, null);
}

public ValidationError check(DisplayerSettings settings) {
  if (dataSetLookupConstraints == null) {
    return createValidationError(ERROR_DATASET_LOOKUP_CONSTRAINTS_NOT_FOUND);
  }
  if (settings.getDataSet() != null) {
    ValidationError error = dataSetLookupConstraints.check(settings.getDataSet());
    if (error != null) return error;
  }
  else if (settings.getDataSetLookup() != null) {
    ValidationError error = dataSetLookupConstraints.check(settings.getDataSetLookup());
    if (error != null) return error;
  }
  return null;
}

public ValidationError check(DisplayerSettings settings) {
  if (dataSetLookupConstraints == null) {
    return createValidationError(ERROR_DATASET_LOOKUP_CONSTRAINTS_NOT_FOUND);
  }
  if (settings.getDataSet() != null) {
    ValidationError error = dataSetLookupConstraints.check(settings.getDataSet());
    if (error != null) return error;
  }
  else if (settings.getDataSetLookup() != null) {
    ValidationError error = dataSetLookupConstraints.check(settings.getDataSetLookup());
    if (error != null) return error;
  }
  return null;
}

@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 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 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 testValidationOk() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DATE).fixed(DateIntervalType.MONTH, true)
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNull(error);
}

@Test
public void testMissingGroup() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_GROUP_REQUIRED);
}

@Test
public void testMissingGroup() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_GROUP_REQUIRED);
}

@Test
public void testColumnMissing() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DEPARTMENT)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_NUMBER);
}

@Test
public void testValidationOk() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DATE).fixed(DateIntervalType.MONTH, true)
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNull(error);
}

@Test
public void testColumnMissing() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DEPARTMENT)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_NUMBER);
}

@Test
public void testWrongColumnType() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DEPARTMENT)
      .column(DEPARTMENT)
      .column(EMPLOYEE)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_TYPE);
  lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DATE)
      .column(DATE)
      .column(EMPLOYEE)
      .buildLookup();
  error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_TYPE);
}

@Test
public void testColumnExcess() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DATE).fixed(DateIntervalType.MONTH, true)
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .column(AMOUNT, AggregateFunctionType.AVERAGE)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_NUMBER);
}

@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 testColumnExcess() {
  DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
      .group(DATE).fixed(DateIntervalType.MONTH, true)
      .column(DATE)
      .column(AMOUNT, AggregateFunctionType.SUM)
      .column(AMOUNT, AggregateFunctionType.AVERAGE)
      .buildLookup();
  ValidationError error = TWO_COLUMNS_GROUPED.check(lookup, METADATA);
  assertNotNull(error);
  assertEquals(error.getCode(), DataSetLookupConstraints.ERROR_COLUMN_NUMBER);
}

@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);
}