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); MinorIssueConfig minorConfig = optionalMinorConfig.get(); newIssue = new Issue( oldIssue.getExplanation(), minorConfig.getSeverity(), oldIssue.getType(), minorConfig.getUrl()); } else {
/** 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")); } }
@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())); }
@JsonCreator private static Issue getIssue( @JsonProperty(PROP_EXPLANATION) String explanation, @JsonProperty(PROP_SEVERITY) Integer severity, @JsonProperty(PROP_TYPE) Type type, @JsonProperty(PROP_URL) String url) { return new Issue( firstNonNull(explanation, ""), requireNonNull(severity, PROP_SEVERITY + " cannot be null"), requireNonNull(type, PROP_TYPE + " cannot be null"), url); }
@Override protected String featureValueOf(Issue actual) { return actual.getType().getMinor(); } }
rowToInteger = r -> r.getInteger(column); } else if (schema.equals(Schema.ISSUE)) { rowToInteger = r -> r.getIssue(column).getSeverity(); } else {
@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)); }
@Override protected String featureValueOf(Issue actual) { return actual.getType().getMajor(); } }
@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 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 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)); }
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);
@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 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())); }
@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)))))); } }
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);
String minor = "minor"; int severity = 1; Issue issueValue = new Issue("a", severity, new Issue.Type(major, minor));