How to use

Issue$Type

in

org.batfish.datamodel.answers

@JsonCreator
private static Type createType(
  @JsonProperty(PROP_MAJOR) String major, @JsonProperty(PROP_MINOR) String minor) {
 return new Type(firstNonNull(major, ""), firstNonNull(minor, ""));
}

 /** Test if Issues are (De)serialiazed properly */
 @Test
 public void testSerDeser() throws IOException {
  String issueStr =
    "{\"explanation\" : \"myex\", \"type\" : { \"major\" : \"maj\", \"minor\": \"min\" }, \"severity\" : 75, \"url\": \"www.cnn.com\"}";
  Issue issue = BatfishObjectMapper.mapper().readValue(issueStr, Issue.class);

  // check if the issue is properly deserialized
  assertThat(issue.getExplanation(), equalTo("myex"));
  assertThat(issue.getType().getMajor(), equalTo("maj"));
  assertThat(issue.getType().getMinor(), equalTo("min"));
  assertThat(issue.getSeverity(), equalTo(75));
  assertThat(issue.getUrl(), equalTo("www.cnn.com"));

  String issueSer = BatfishObjectMapper.mapper().writeValueAsString(issue);
  ObjectNode issueObj = (ObjectNode) BatfishObjectMapper.mapper().readTree(issueSer);

  // check serialization
  assertThat(issueObj.get("explanation").asText(), equalTo("myex"));
  assertThat(issueObj.get("severity").asInt(), equalTo(75));
  assertThat(issueObj.get("url").asText(), equalTo("www.cnn.com"));
  assertThat(issueObj.get("type").get("major").asText(), equalTo("maj"));
  assertThat(issueObj.get("type").get("minor").asText(), equalTo("min"));
 }
}

 @Override
 protected String featureValueOf(Issue actual) {
  return actual.getType().getMajor();
 }
}

@Test
public void testApplyRowIssuesConfigurationNoMatchMajorIssue() {
 String col = "col";
 String major = "major";
 String otherMajor = "otherMajor";
 String minor = "minor";
 Row oldRow = Row.of(col, new Issue("explanation", 5, new Issue.Type(major, minor)));
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     otherMajor,
     new MajorIssueConfig(
       otherMajor, ImmutableList.of(new MinorIssueConfig(minor, 6, "example.com"))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs), equalTo(oldRow));
}

@Test
public void testApplyRowIssuesConfigurationNoMatchMinorIssue() {
 String col = "col";
 String major = "major";
 String otherMinor = "otherMinor";
 String minor = "minor";
 Row oldRow = Row.of(col, new Issue("explanation", 5, new Issue.Type(major, minor)));
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     major,
     new MajorIssueConfig(
       major, ImmutableList.of(new MinorIssueConfig(otherMinor, 6, "example.com"))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs), equalTo(oldRow));
}

@Test
public void testApplyRowIssuesConfigurationMatch() {
 String col = "col";
 String major = "major";
 String minor = "minor";
 Issue oldIssue = new Issue("explanation", 5, new Issue.Type(major, minor));
 Row oldRow = Row.of(col, oldIssue);
 int newSeverity = 6;
 String newUrl = "example.com";
 Issue newIssue = new Issue(oldIssue.getExplanation(), newSeverity, oldIssue.getType(), newUrl);
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     major,
     new MajorIssueConfig(major, ImmutableList.of(new MinorIssueConfig(minor, 6, newUrl))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs),
   equalTo(Row.of(col, newIssue)));
}

@Test
public void testComputeColumnMaxOneRowIssue() {
 String columnName = "col";
 int severity = 5;
 Issue value = new Issue("blah", severity, new Issue.Type("1", "2"));
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), equalTo(severity));
}

 @Test
 public void testComputeMajorIssueTypesSome() {
  String columnName = "col";
  String major = "major";
  String minor = "minor";
  int severity = 5;
  Issue value = new Issue("a", severity, new Issue.Type(major, minor));

  TableAnswerElement table =
    new TableAnswerElement(
        new TableMetadata(
          ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar")),
          new DisplayHints().getTextDesc()))
      .addRow(Row.of(columnName, value));

  assertThat(
    AnswerMetadataUtil.computeMajorIssueConfigs(table),
    equalTo(
      ImmutableMap.of(
        major,
        new MajorIssueConfig(
          major, ImmutableMap.of(minor, new MinorIssueConfig(minor, severity, null))))));
 }
}

@Test
public void testProcessAnswerRows2() throws IOException {
 String columnName = "issue";
 int maxRows = 1;
 int rowOffset = 0;
 TableAnswerElement table =
   new TableAnswerElement(
     new TableMetadata(
       ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
 table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
 Answer answer = new Answer();
 answer.addAnswerElement(table);
 answer.setStatus(AnswerStatus.SUCCESS);
 String answerStr = BatfishObjectMapper.writePrettyString(answer);
 AnswerRowsOptions options =
   new AnswerRowsOptions(
     ImmutableSet.of(columnName),
     ImmutableList.of(),
     maxRows,
     rowOffset,
     ImmutableList.of(new ColumnSortOption(columnName, true)),
     false);
 List<Row> processedRows =
   ((TableView) _manager.processAnswerRows2(answerStr, options).getAnswerElements().get(0))
     .getInnerRows();
 assertThat(processedRows, equalTo(table.getRowsList()));
}

@Test
public void testProcessAnswerRows() throws IOException {
 String columnName = "issue";
 int maxRows = 1;
 int rowOffset = 0;
 TableAnswerElement table =
   new TableAnswerElement(
     new TableMetadata(
       ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
 table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
 Answer answer = new Answer();
 answer.addAnswerElement(table);
 answer.setStatus(AnswerStatus.SUCCESS);
 String answerStr = BatfishObjectMapper.writePrettyString(answer);
 AnswerRowsOptions options =
   new AnswerRowsOptions(
     ImmutableSet.of(columnName),
     ImmutableList.of(),
     maxRows,
     rowOffset,
     ImmutableList.of(new ColumnSortOption(columnName, true)),
     false);
 List<Row> processedRows =
   ((TableAnswerElement)
       _manager.processAnswerRows(answerStr, options).getAnswerElements().get(0))
     .getRowsList();
 assertThat(processedRows, equalTo(table.getRowsList()));
}

1,
colIssue,
new Issue("blah", 1, new Issue.Type("major", "minor")),
colString,
"a");
2,
colIssue,
new Issue("blah", 2, new Issue.Type("major", "minor")),
colString,
"b");

MajorIssueConfig config = issueConfigs.get(oldIssue.getType().getMajor());
Issue newIssue;
if (config == null) {
 newIssue = oldIssue;
} else {
 String minorIssue = oldIssue.getType().getMinor();
 Optional<MinorIssueConfig> optionalMinorConfig =
   config.getMinorIssueConfig(minorIssue);

    new TableMetadata(
      ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
Answer answer = new Answer();
answer.addAnswerElement(table);

 @Override
 protected String featureValueOf(Issue actual) {
  return actual.getType().getMinor();
 }
}

String minor = "minor";
int severity = 1;
Issue issueValue = new Issue("a", severity, new Issue.Type(major, minor));

@Test
public void testColumnComparatorIssue() {
 String col = "col1";
 ColumnMetadata columnMetadata = new ColumnMetadata(col, Schema.ISSUE, "colDesc");
 Comparator<Row> comparator = _manager.columnComparator(columnMetadata);
 Row r1 = Row.of(col, new Issue("a", 1, new Issue.Type("major", "minor")));
 Row r2 = Row.of(col, new Issue("a", 2, new Issue.Type("major", "minor")));
 Row r3 = Row.of(col, new Issue("b", 1, new Issue.Type("major", "minor")));
 assertThat(comparator.compare(r1, r2), lessThan(0));
 assertThat(comparator.compare(r1, r3), equalTo(0));
 assertThat(comparator.compare(r2, r3), greaterThan(0));
}

  new TableAnswerElement(
    new TableMetadata(ImmutableList.of(new ColumnMetadata(col, Schema.ISSUE, "desc"))));
oldTable.addRow(Row.of(col, new Issue("blah", 1, new Issue.Type(major, minor))));
oldTable.addExcludedRow(
  Row.of(col, new Issue("blorp", 1, new Issue.Type(major, minor))), "exc");
oldAnswer.setAnswerElements(ImmutableList.of(oldTable));
AnswerMetadata oldAnswerMetadata =
      BatfishObjectMapper.mapper()
        .valueToTree(
          Row.of(col, new Issue("blorp", 1, new Issue.Type(major, minor)))))));
String questionContent = BatfishObjectMapper.writeString(testQuestion);
_storage.storeQuestion(questionContent, networkId, questionId, analysisId);

@VisibleForTesting
static @Nonnull Map<String, MajorIssueConfig> computeMajorIssueConfigs(TableAnswerElement table) {
 Map<String, ImmutableList.Builder<MinorIssueConfig>> majorIssueConfigs = new HashMap<>();
 // For every issue column of every row, extract the issue and use it to update the map
 table.getMetadata().getColumnMetadata().stream()
   .filter(c -> c.getSchema().equals(Schema.ISSUE))
   .map(ColumnMetadata::getName)
   .flatMap(
     column ->
       table.getRowsList().stream()
         .filter(row -> row.hasNonNull(column))
         .map(row -> row.getIssue(column)))
   .forEach(
     issue ->
       majorIssueConfigs
         .computeIfAbsent(issue.getType().getMajor(), m -> ImmutableList.builder())
         .add(
           new MinorIssueConfig(
             issue.getType().getMinor(), issue.getSeverity(), issue.getUrl())));
 return CommonUtil.toImmutableMap(
   majorIssueConfigs,
   Entry::getKey, // major issue type
   e -> new MajorIssueConfig(e.getKey(), e.getValue().build()));
}