src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DAStringUtil { public static String normalizeWhiteSpaceFromString(String content) { if (content == null) { return null; } final Matcher matcher = pattern.matcher(content); final String s = matcher.replaceAll(" ").trim(); if (s.isEmpty()) { return null; } return s; } static String normalizeWhiteSpaceFromString(String content); static String normalizeWhiteSpaceFromStringOld(String content); static final Predicate<String> STRING_IS_BLANK; } | @Test public void testNormalizeWhiteSpaceFromString() throws Exception { assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(null)); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \r\n ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \r ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString("")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \n ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromString(" a \n \n a ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromString(" \t a \n \n \t a \t ")); } |
SimpleDataSourceComparator implements CatoDataSourceComparator { FieldBreak compareDataObjects(CatoDataObject leftObj, CatoDataObject rightObj) { if (leftObj == null || rightObj == null) { LOG.error("Cannot compare null DataObjects"); throw new IllegalArgumentException("Cannot compare null DataObjects"); } Object leftVal; Object rightVal; Set<String> comparedRightFields = new HashSet<String>(); Map<String, Object> fieldBreaks = new HashMap<String, Object>(); for (String field : leftObj.getFields()) { if (this.properties.getExcludeFields().contains(field)) { continue; } leftVal = leftObj.getValue(field); rightVal = rightObj.getValue(this.getRightField(field)); if (this.properties.getKeyFields().contains(field)) { if (this.dataComparator.compareKeyValues(leftVal, rightVal) != 0) { LOG.error("Cannot compare data objects with different keys\n{}\n{}", leftObj, rightObj); throw new IllegalArgumentException("Cannot compare data objects with different keys"); } continue; } if (!this.dataComparator.compareValues(leftVal, rightVal)) { fieldBreaks.put(field, rightVal); } comparedRightFields.add(this.getRightField(field)); } for (String rightField : rightObj.getFields()) { if (this.properties.getKeyFields().contains(rightField) || this.properties.getExcludeFields().contains(rightField) || comparedRightFields.contains(rightField) || this.properties.getMappedFields().containsKey(rightField)) { continue; } fieldBreaks.put(rightField, rightObj.getValue(rightField)); } if (fieldBreaks.size() > 0) { return new FieldBreak(leftObj, fieldBreaks); } else { return null; } } SimpleDataSourceComparator(CatoProperties properties, Comparator<CatoDataObject> dataObjectComparator,
CatoDataComparator dataComparator, Sort<CatoDataObject> sort,
Factory<Collection<Break>> breakCollectionFactory, Factory<Collection<CatoDataObject>> dataCollectionFactory); CatoComparison compare(String comparisonName, CatoDataSource leftDataSource, CatoDataSource rightDataSource); } | @Test public void testCompareDataObjectsWithNullObjects() { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "3"); this.obj2 = TestUtil.createDataObject("A", "A", "1", "2", "3"); try { comparator.compareDataObjects(null, null); Assert.fail(); } catch (IllegalArgumentException ex) { } catch (Exception ex) { Assert.fail(); } try { comparator.compareDataObjects(this.obj1, null); Assert.fail(); } catch (IllegalArgumentException ex) { } catch (Exception ex) { Assert.fail(); } try { comparator.compareDataObjects(null, this.obj2); Assert.fail(); } catch (IllegalArgumentException ex) { } catch (Exception ex) { Assert.fail(); } }
@Test public void testCompareDataObjectsNoBreak() { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "3"); this.obj2 = TestUtil.createDataObject("A", "A", "1", "2", "3"); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); }
@Test public void testCompareDataObjectsWithBreak() { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "3"); this.obj2 = TestUtil.createDataObject("A", "A", "1", "4", "3"); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); }
@Test public void testCompareDataObjectsWithBreaks2() { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "5"); this.obj2 = TestUtil.createDataObject("A", "A", "1", "4", "5"); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); }
@Test public void testCompareDataObjectsWithExcludes() { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "3", "4"); this.obj2 = TestUtil.createDataObject("A", "A", "1", "2", "3", "5"); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); }
@Test public void testCompareDataObjectsWithDifferentKeys() { try { this.obj1 = TestUtil.createDataObject("A", "A", "1", "2", "3"); this.obj2 = TestUtil.createDataObject("A", "B", "1", "2", "3"); comparator.compareDataObjects(this.obj1, this.obj2); Assert.fail(); } catch (IllegalArgumentException ex) { } catch (Exception ex) { Assert.fail(); } }
@Test public void testCompareDataObjectsMissingFields() { this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.properties.getExcludeFields().add("C"); System.out.println("-------" + this.properties.getExcludeFields()); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.properties.getExcludeFields().remove("C"); }
@Test public void testCompareDataObjectsWithMappedFields() { this.properties.addMappedField("C", "D"); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 4); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "D", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "D", 3); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "D", 3); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "D", 3); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.properties.getExcludeFields().add("E"); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "E", 4); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3, "E", 44); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.properties.getMappedFields().remove("C"); this.properties.getExcludeFields().remove("E"); }
@Test public void testCompareDataObjectsWithMissingAndMappedAndExcludeFields() { this.properties.addMappedField("C", "D"); this.properties.getExcludeFields().add("Q"); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "Q", 4); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3, "Q", 44); Assert.assertNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "E", 4, "Q", 4); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3, "Q", 44); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); this.obj1 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "C", 3, "Q", 4); this.obj2 = TestUtil.createDataObjectWithKeys("A", 1, "B", 2, "D", 3, "E", 4, "Q", 44); Assert.assertNotNull(comparator.compareDataObjects(this.obj1, this.obj2)); } |
SimpleDataComparator implements CatoDataComparator { @Override public int compareKeyValues(Object val1, Object val2) { return this.compare(val1, val2, true); } SimpleDataComparator(); SimpleDataComparator(int decimalPrecision); @Override boolean compareValues(Object val1, Object val2); @Override int compareKeyValues(Object val1, Object val2); } | @Test public void testCompareKeyIntegers() { Assert.assertEquals(0, comparator.compareKeyValues(3, 3)); Assert.assertEquals(-1, comparator.compareKeyValues(3, 5)); Assert.assertEquals(1, comparator.compareKeyValues(4, 2)); }
@Test public void testCompareKeyDoubles() { Assert.assertEquals(0, comparator.compareKeyValues(1.43567d, 1.43567d)); Assert.assertEquals(-1, comparator.compareKeyValues(1.43552d, 2.45673d)); Assert.assertEquals(1, comparator.compareKeyValues(1.43567d, 1.43552d)); Assert.assertEquals(0, comparator.compareKeyValues(1.43562d, 1.43564d)); Assert.assertEquals(-1, comparator.compareKeyValues(1.43564d, 1.43566d)); SimpleDataComparator comparator2 = new SimpleDataComparator(0); Assert.assertEquals(0, comparator2.compareKeyValues(1.4, 1.2)); Assert.assertEquals(-1, comparator2.compareKeyValues(1.4, 1.6)); Assert.assertEquals(0, comparator2.compareKeyValues(1.5, 2.0)); Assert.assertEquals(-1, comparator2.compareKeyValues(1.5, 2.51)); }
@Test public void testCompareKeyFloats() { Assert.assertEquals(0, comparator.compareKeyValues(1.43567f, 1.43567f)); Assert.assertEquals(-1, comparator.compareKeyValues(1.43552f, 2.45673f)); Assert.assertEquals(1, comparator.compareKeyValues(1.43567f, 1.43552f)); Assert.assertEquals(0, comparator.compareKeyValues(1.43562f, 1.43564f)); Assert.assertEquals(-1, comparator.compareKeyValues(1.43562f, 1.43567f)); }
@Test public void testCompareNumberTypes() { Assert.assertEquals(0, comparator.compareKeyValues(1.5d, 1.5f)); Assert.assertEquals(1, comparator.compareKeyValues(3.1d, 3)); Assert.assertEquals(0, comparator.compareKeyValues((short) 3, 3)); Assert.assertEquals(1, comparator.compareKeyValues(new BigDecimal(5.0001), 5.0d)); Assert.assertEquals(0, comparator.compareKeyValues(new BigDecimal(5), 5)); } |
SimpleDataComparator implements CatoDataComparator { @Override public boolean compareValues(Object val1, Object val2) { return this.compare(val1, val2, false) == 0; } SimpleDataComparator(); SimpleDataComparator(int decimalPrecision); @Override boolean compareValues(Object val1, Object val2); @Override int compareKeyValues(Object val1, Object val2); } | @Test public void testCompareIntegers() { Assert.assertTrue(comparator.compareValues(3, 3)); Assert.assertFalse(comparator.compareValues(3, 5)); Assert.assertFalse(comparator.compareValues(4, 2)); }
@Test public void testCompareDoubles() { Assert.assertTrue(comparator.compareValues(1.43567d, 1.43567d)); Assert.assertFalse(comparator.compareValues(1.43552d, 2.45673d)); Assert.assertFalse(comparator.compareValues(1.43567d, 1.43552d)); Assert.assertTrue(comparator.compareValues(1.43562d, 1.43564d)); Assert.assertTrue(comparator.compareValues(1.43562d, 1.43567d)); SimpleDataComparator comparator2 = new SimpleDataComparator(0); Assert.assertTrue(comparator2.compareValues(1.4d, 1.2d)); Assert.assertTrue(comparator2.compareValues(1.4d, 1.6d)); Assert.assertTrue(comparator2.compareValues(1.5d, 2.0d)); Assert.assertFalse(comparator2.compareValues(1.5d, 2.51d)); SimpleDataComparator comparator3 = new SimpleDataComparator(-2); Assert.assertTrue(comparator3.compareValues(140, 120)); Assert.assertTrue(comparator3.compareValues(140, 160)); Assert.assertTrue(comparator3.compareValues(150, 200)); Assert.assertFalse(comparator3.compareValues(150, 251)); }
@Test public void testStringCompare() { Assert.assertTrue(comparator.compareValues("abcde", "abcde")); Assert.assertFalse(comparator.compareValues("abcde", "abcdq")); Assert.assertTrue(comparator.compareValues("abcde ", " abcde")); Assert.assertFalse(comparator.compareValues("abcde ", " abcdq")); }
@Test public void testDateCompare() { Date date1 = new Date(); Date date2 = new Date(date1.getTime()); Date date3 = new Date(date1.getTime() + 100); Assert.assertTrue(comparator.compareValues(date1, date2)); Assert.assertFalse(comparator.compareValues(date1, date3)); Timestamp timestamp = new Timestamp(date1.getTime()); Assert.assertEquals(date1.getTime(), timestamp.getTime()); org.junit.Assert.assertTrue(comparator.compareValues(date1, timestamp)); org.junit.Assert.assertTrue(comparator.compareValues(timestamp, date1)); org.junit.Assert.assertTrue(comparator.compareValues(date2, timestamp)); org.junit.Assert.assertFalse(comparator.compareValues(date3, timestamp)); } |
SimpleBreakExcluder implements CatoBreakExcluder { public void excludeBreaks(Iterable<Break> breaks, Collection<BreakExclude> breakExcludes) { Collection<String> fields = new HashSet<String>(); FieldBreak fieldBreak; for (Break br : breaks) { fields.clear(); for (BreakExclude exclude : breakExcludes) { if (!this.matchesKey(exclude, br.getDataObject())) { continue; } if (this.matchesAnything(exclude)) { br.setExcluded(true); break; } if (br instanceof FieldBreak) { fieldBreak = (FieldBreak) br; for (String field : fieldBreak.getFields()) { if (this.matchesData(exclude, field, fieldBreak.getActualValue(field), fieldBreak.getExpectedValue(field))) { fieldBreak.setExcluded(field, true); fields.add(field); } } } } if (br instanceof FieldBreak && fields.size() == ((FieldBreak) br).getFields().size()) { br.setExcluded(true); } } } SimpleBreakExcluder(CatoDataComparator comparator); void excludeBreaks(Iterable<Break> breaks, Collection<BreakExclude> breakExcludes); } | @Test public void excludeRowTest() { this.breakExcludes.add(TestUtil.createBreakExclude("B", "A", null, null, null)); this.breakExcludes.add(TestUtil.createBreakExclude("C", "C", null, null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(2, this.getExcludeCount()); }
@Test public void excludeRowGroupTest() { this.breakExcludes.add(TestUtil.createBreakExclude("D", "A", null, null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(3, this.getExcludeCount()); }
@Test public void excludeRowFieldTest() { this.breakExcludes.add(TestUtil.createBreakExclude("B", "B", TestUtil.ALL_FIELDS.get(0), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); this.breakExcludes.add(TestUtil.createBreakExclude("B", "B", TestUtil.ALL_FIELDS.get(3), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); this.breakExcludes.add(TestUtil.createBreakExclude("B", "B", TestUtil.ALL_FIELDS.get(4), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(1, this.getExcludeCount()); org.junit.Assert.assertEquals(2, this.getExcludeFieldCount()); }
@Test public void excludeRowFieldTest2() { this.breakExcludes.add(TestUtil.createBreakExclude("D", "A", TestUtil.ALL_FIELDS.get(0), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); this.breakExcludes.add(TestUtil.createBreakExclude("B", "B", TestUtil.ALL_FIELDS.get(2), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); this.breakExcludes.add(TestUtil.createBreakExclude("B", "B", TestUtil.ALL_FIELDS.get(3), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); }
@Test public void excludeFieldTest() { this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(3), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); }
@Test public void excludeFieldTest2() { this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), null, null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(1, this.getExcludeCount()); org.junit.Assert.assertEquals(2, this.getExcludeFieldCount()); }
@Test public void excludeFieldValueTest() { this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), "6", null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); }
@Test public void excludeFieldValueTest2() { this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), "6", "8")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(0, this.getExcludeFieldCount()); this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), "6", "7")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); }
@Test public void excludeFieldValueTest3() { this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), null, "6")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(0, this.getExcludeFieldCount()); this.breakExcludes.add(TestUtil.createBreakExclude(TestUtil.ALL_FIELDS.get(4), null, "7")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); }
@Test public void excludeValueTest() { this.breakExcludes.add(TestUtil.createBreakExclude(null, "7", "8")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(1, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); }
@Test public void excludeValueTest2() { this.breakExcludes.add(TestUtil.createBreakExclude(null, "3", "4")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); this.breakExcludes.add(TestUtil.createBreakExclude(null, "3", null)); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(1, this.getExcludeCount()); org.junit.Assert.assertEquals(2, this.getExcludeFieldCount()); }
@Test public void excludeValueTest3() { this.breakExcludes.add(TestUtil.createBreakExclude(null, null, "4")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(0, this.getExcludeCount()); org.junit.Assert.assertEquals(1, this.getExcludeFieldCount()); this.breakExcludes.add(TestUtil.createBreakExclude(null, null, "7")); this.breakExcluder.excludeBreaks(this.breaks, this.breakExcludes); org.junit.Assert.assertEquals(1, this.getExcludeCount()); org.junit.Assert.assertEquals(2, this.getExcludeFieldCount()); } |
RevengPattern { public RevengPatternOutput evaluate(String input) { final Matcher matcher = pattern.matcher(input); if (matcher.find()) { String primaryName = matcher.group(namePatternType.getObjectIndex(primaryNameIndex)); String schema = getMatcherGroup(matcher, namePatternType.getSchemaIndex(primaryNameIndex)); String subSchema = getMatcherGroup(matcher, namePatternType.getSubSchemaIndex(primaryNameIndex)); if (namePatternType.getSubSchemaIndex(primaryNameIndex) != null && schema != null && subSchema == null) { subSchema = schema; schema = null; } String secondaryName = null; if (secondaryNameIndex != null) { secondaryName = matcher.group(namePatternType.getObjectIndex(secondaryNameIndex)); if (schema == null) { schema = getMatcherGroup(matcher, namePatternType.getSchemaIndex(secondaryNameIndex)); } if (subSchema == null) { subSchema = getMatcherGroup(matcher, namePatternType.getSubSchemaIndex(secondaryNameIndex)); } if (namePatternType.getSubSchemaIndex(secondaryNameIndex) != null && schema != null && subSchema == null) { subSchema = schema; schema = null; } } return new RevengPatternOutput(this, primaryName, secondaryName, schema, subSchema, input); } return null; } RevengPattern(String changeType, NamePatternType namePatternType, String pattern); private RevengPattern(String changeType, NamePatternType namePatternType, String pattern, int primaryNameIndex); RevengPattern(String changeType, NamePatternType namePatternType, String pattern, int primaryNameIndex, Integer secondaryNameIndex, String annotation); NamePatternType getNamePatternType(); Pattern getPattern(); int getPrimaryNameIndex(); Integer getSecondaryNameIndex(); RevengPattern withPostProcessSql(Function<String, LineParseOutput> postProcessSql); RevengPattern withSuggestedOrder(Integer suggestedOrder); void setShouldBeIgnored(boolean shouldBeIgnored); RevengPattern withShouldBeIgnored(boolean shouldBeIgnored); boolean isKeepLastOnly(); void setKeepLastOnly(boolean keepLastOnly); RevengPattern withKeepLastOnly(boolean keepLastOnly); String remapObjectName(String candidateObject); RevengPattern withRemapObjectName(Function<String, String> remapObjectName); RevengPatternOutput evaluate(String input); @Override String toString(); static final Function<RevengPattern, String> TO_CHANGE_TYPE; } | @Test public void testFullSubschema() { RevengPatternOutput output = subschemaPattern.evaluate("pat A.B.C"); assertThat(output.getSchema(), equalTo("A")); assertThat(output.getSubSchema(), equalTo("B")); assertThat(output.getPrimaryName(), equalTo("C")); }
@Test public void testPartialSubschema() { RevengPatternOutput output = subschemaPattern.evaluate("pat B.C"); assertThat(output.getSchema(), equalTo(null)); assertThat(output.getSubSchema(), equalTo("B")); assertThat(output.getPrimaryName(), equalTo("C")); }
@Test public void testBlankSubschema() { RevengPatternOutput output = subschemaPattern.evaluate("pat C"); assertThat(output.getSchema(), equalTo(null)); assertThat(output.getSubSchema(), equalTo(null)); assertThat(output.getPrimaryName(), equalTo("C")); }
@Test public void testFullSchema() { RevengPatternOutput output = schemaPattern.evaluate("pat A.B"); assertThat(output.getSchema(), equalTo("A")); assertThat(output.getSubSchema(), equalTo(null)); assertThat(output.getPrimaryName(), equalTo("B")); }
@Test public void testBlankSchema() { RevengPatternOutput output = schemaPattern.evaluate("pat B"); assertThat(output.getSchema(), equalTo(null)); assertThat(output.getSubSchema(), equalTo(null)); assertThat(output.getPrimaryName(), equalTo("B")); } |
SimpleDataSchema implements CatoDataSchema { @Override public Map<String, String> getMappedFields() { return this.mappedFields; } SimpleDataSchema(); SimpleDataSchema(Map<String, String> mappedFields); @Override Set<String> getFields(); @Override SimpleDataObject createDataObject(); @Override Map<String, String> getMappedFields(); } | @Test public void testConstructor() { Assert.assertEquals(0, this.schema.getMappedFields().size()); Map<String, String> mappedFields = new HashMap<String, String>(); mappedFields.put("Test1", "Test1 Ref"); mappedFields.put("Test2", "Test2 Ref"); this.schema = new SimpleDataSchema(mappedFields); Assert.assertEquals(2, this.schema.getMappedFields().size()); } |
SimpleDataSchema implements CatoDataSchema { @Override public SimpleDataObject createDataObject() { return new SimpleDataObject(this); } SimpleDataSchema(); SimpleDataSchema(Map<String, String> mappedFields); @Override Set<String> getFields(); @Override SimpleDataObject createDataObject(); @Override Map<String, String> getMappedFields(); } | @Test public void testCreateDataObject() { SimpleDataObject obj = this.schema.createDataObject(); Assert.assertNotNull(obj); Assert.assertSame(this.schema, obj.getSchema()); } |
SimpleDataObject implements CatoDataObject { @Override public CatoDataSchema getSchema() { return this.schema; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); } | @Test public void getSchemaTest() { Assert.assertSame(schema, obj.getSchema()); Assert.assertSame(schema, obj2.getSchema()); } |
SimpleDataObject implements CatoDataObject { @Override public void setValue(String field, Object value) { int index = this.schema.getOrCreateFieldIndex(field); if (this.data.length <= index) { this.data = this.copy(this.data, index + 1); } this.data[index] = value; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); } | @Test public void setValueTest() { Assert.assertEquals(7, obj.getFields().size()); Assert.assertEquals(7, obj2.getFields().size()); Assert.assertNull(obj.getValue("x")); Assert.assertNull(obj.getValue("axax")); Assert.assertNull(obj2.getValue("a")); Assert.assertNull(obj2.getValue("b")); Assert.assertNull(obj2.getValue("e")); } |
SimpleDataObject implements CatoDataObject { @Override public Set<String> getFields() { return this.schema.getFields(); } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); } | @Test public void containsFieldTest() { Assert.assertTrue(obj.getFields().contains("a")); Assert.assertTrue(obj.getFields().contains("d")); Assert.assertFalse(obj.getFields().contains("f")); } |
SimpleDataObject implements CatoDataObject { @Override public Object getValue(String field) { Integer index = this.schema.getFieldIndex(field); if (index == null || this.data.length <= index) { return null; } return this.data[index]; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); } | @Test public void getValueTest() { Assert.assertEquals(123, obj.getValue("a")); Assert.assertEquals(true, obj.getValue("b")); Assert.assertEquals("test string", obj.getValue("c")); Assert.assertNull(obj.getValue("d")); Assert.assertEquals(Arrays.asList(1, 2, 3), obj.getValue("e")); Assert.assertNull(obj.getValue("f")); } |
SimpleDataObject implements CatoDataObject { @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append(this.getClass().getSimpleName()).append(" {"); if (this.getFields().isEmpty()) { return builder.append("}").toString(); } for (String field : this.getFields()) { builder.append(field).append("=").append(this.getValue(field)).append(this.getClass(field)).append(", "); } return builder.substring(0, builder.length() - 2) + "}"; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); } | @Test public void toStringTest() { try { Assert.assertEquals( "SimpleDataObject {}", TestUtil.createDataObjectWithKeys().toString()); Assert.assertEquals( "SimpleDataObject {Key 1=A [String], Key 2=4 [Integer], Val 1=1.4 [Double], Val 2=str [String], Val 3=[1, 2, 3] [ArrayList]}", TestUtil.createDataObject("A", 4, 1.4, "str", Arrays.asList(1, 2, 3)).toString()); Assert.assertEquals( "SimpleDataObject {Key 1=A [String], Key 2=null, Val 1=1.4 [Double], Val 2=null, Val 3=[1, null, 3] [ArrayList]}", TestUtil.createDataObject("A", null, 1.4, null, Arrays.asList(1, null, 3)).toString()); Assert.assertEquals( "SimpleDataObject {Key 1=null, Key 2=null, Val 1=null, Val 2=null, Val 3=[null, null, 3] [ArrayList]}", TestUtil.createDataObject(null, null, null, null, Arrays.asList(null, null, 3)).toString()); } catch (Exception ex) { Assert.fail(); } } |
CatoFieldSelector implements Function<CatoDataObject, Object> { @Override public Object valueOf(CatoDataObject obj) { return obj.getValue(this.field); } CatoFieldSelector(String field); @Override Object valueOf(CatoDataObject obj); } | @Test public void testSelector() { CatoDataObject obj = TestUtil.createDataObjectWithKeys("Val1", 123, "Val2", 555.5, "Val 3", "abc"); Assert.assertEquals(123, new CatoFieldSelector("Val1").valueOf(obj)); org.junit.Assert.assertEquals(555.5, new CatoFieldSelector("Val2").valueOf(obj)); org.junit.Assert.assertEquals("abc", new CatoFieldSelector("Val 3").valueOf(obj)); assertNull(new CatoFieldSelector("Not a val").valueOf(obj)); assertNull(new CatoFieldSelector(null).valueOf(obj)); } |
MemoryMonitor extends Thread { private MemoryMonitor() { this(2000, true); } private MemoryMonitor(); MemoryMonitor(long pollFrequency, boolean logMemoryUsage); void run(); double getCurrentMemory(); double getMaxMemory(); void terminate(); } | @Test public void testMemoryMonitor() { MemoryMonitor monitor = new MemoryMonitor(10, true); Assert.assertEquals(0.0, monitor.getCurrentMemory(), 0.01); Assert.assertEquals(0.0, monitor.getMaxMemory(), 0.01); Assert.assertTrue(monitor.isDaemon()); monitor.start(); this.sleep(100); Assert.assertTrue(monitor.isAlive()); Assert.assertTrue(monitor.getCurrentMemory() > 0); Assert.assertTrue(monitor.getMaxMemory() > 0); monitor.terminate(); this.sleep(50); Assert.assertFalse(monitor.isAlive()); org.junit.Assert.assertTrue(monitor.getCurrentMemory() > 0); org.junit.Assert.assertTrue(monitor.getMaxMemory() > 0); } |
CatoResources { public CatoResources(InputStream is) throws CatoResourcesException { this.initialize(is); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testCatoResources() { try { new CatoResources(this.getClass().getClassLoader() .getResourceAsStream("TestResources.xml")); LOG.info("Cato resources created."); } catch (CatoResourcesException e) { LOG.error("Unable to read the resources - {}", e.getMessage()); fail("Unable to read the resources - " + e.getMessage()); } } |
CatoResources { public DataSourceConfig getDataSource(String name) { for (DataSourceConfig dsc : this.dataSources.values()) { if (dsc.getName().equals(name)) { return dsc; } } return null; } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testGetDataSource() { DataSourceConfig dsc = this.catoResources.getDataSource("ds0"); if (dsc == null) { fail("Could not find data source ds0."); } } |
CatoResources { public ReconConfig getRecon(String name) { for (ReconConfig rc : this.recons.values()) { if (rc.getReconName().equals(name)) { return rc; } } return null; } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testGetRecon() { ReconConfig rc = this.catoResources.getRecon("recon0"); if (rc == null) { fail("Could not find recon recon0"); } } |
CatoResources { public void addDataSource(DataSourceConfig ds) { this.dataSources.put(ds.getName(), ds); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testAddDataSource() { DatabaseConfig dbconfig = new DatabaseConfig("ds2", "user2", "password2", "url2", "query2"); this.catoResources.addDataSource(dbconfig); if (this.catoResources.getDataSource("ds2") == null) { fail("Could not add data source ds2."); } } |
CatoResources { public DataSourceConfig removeDataSource(DataSourceConfig ds) { return this.dataSources.remove(ds.getName()); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testRemoveDataSource() { DataSourceConfig dsc = this.catoResources.getDataSource("ds0"); this.catoResources.removeDataSource(dsc); dsc = this.catoResources.getDataSource("ds0"); if (dsc != null) { fail("Could not remove data source ds2."); } } |
CatoResources { public void addRecon(ReconConfig r) { this.recons.put(r.getReconName(), r); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testAddRecon() { ReconConfig rc = new ReconConfig(); rc.setReconName("recon1"); this.catoResources.addRecon(rc); rc = this.catoResources.getRecon("recon1"); if (rc == null) { fail("Unable to add recon recon1."); } } |
CatoResources { public ReconConfig removeRecon(ReconConfig r) { return this.recons.remove(r.getReconName()); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); } | @Test public void testRemoveRecon() { ReconConfig rc = this.catoResources.getRecon("recon0"); this.catoResources.removeRecon(rc); rc = this.catoResources.getRecon("recon0"); if (rc != null) { fail("Unable to remove recon - recon0"); } } |
QueryDataSource extends AbstractCatoDataSource { public QueryDataSource(String name, String url, String user, String password, String query) throws SQLException { this(name, DriverManager.getConnection(url, user, password), query); } QueryDataSource(String name, String url, String user, String password, String query); QueryDataSource(String name, Connection connection, String query); QueryDataSource(String name, Connection connection, QueryExecutor queryExecutor); Connection getConnection(); } | @Test public void queryDataSourceTest() throws Exception { QueryDataSource dataSource = new QueryDataSource("test", DB_URL, "test", "", "select * from Test"); Assert.assertFalse(dataSource.getConnection().isClosed()); List<CatoDataObject> data = TestUtil.getData(dataSource); Assert.assertTrue(dataSource.getConnection().isClosed()); Assert.assertEquals(4, data.size()); CatoDataObject obj = data.get(0); Assert.assertEquals(5, obj.getFields().size()); Assert.assertEquals(1, obj.getValue("KEY")); Assert.assertEquals("abc", obj.getValue("STR_VAL")); Assert.assertEquals("def", obj.getValue("STR_VAL2")); Assert.assertEquals(5.25, ((BigDecimal) obj.getValue("DOUBLE_VAL")).doubleValue(), 0.00001); Assert.assertEquals(new SimpleDateFormat("yyyy-MM-dd").parse("2010-05-12"), obj.getValue("DATE_VAL")); Assert.assertEquals(4, TestUtil.getData( new QueryDataSource("test", DB_URL, "test", "", "select * from Test")).size()); } |
FixedStreamDataSource extends AbstractStreamDataSource { private void parseFields(Object[] fieldInput) { if (fieldInput.length == 0) { throw new IllegalArgumentException("Input field list must not be empty"); } if (fieldInput.length % 3 != 0) { throw new IllegalArgumentException("Input field list must be of form '[<field>, <start index>, <end index>]*'"); } for (int i = 0; i < fieldInput.length; i += 3) { if (!(fieldInput[i] instanceof String) || !(fieldInput[i + 1] instanceof Integer) || !(fieldInput[i + 2] instanceof Integer)) { throw new IllegalArgumentException("Input field list must be of form '[<field>, <start index>, <end index>]*'"); } this.fixedFields.add(new FixedField((String) fieldInput[i], (Integer) fieldInput[i + 1], (Integer) fieldInput[i + 2])); } Collections.sort(this.fixedFields); this.fields.clear(); for (FixedField field : this.fixedFields) { this.fields.add(field.field); } } FixedStreamDataSource(String name, Reader reader, Object... fieldInput); void setHeader(boolean hasHeader); } | @Test public void parseFieldsTest() { try { this.dataSource = new FixedStreamDataSource( "Test", new StringReader(TEST_FILE), "Num", 0, 3, "String", 3, 7, "Test", 8, 12, "Digit", 14, 19); this.dataSource.setTypeConverter(null); List<CatoDataObject> data = TestUtil.getData(this.dataSource); Assert.assertEquals(3, data.size()); CatoDataObject obj1 = data.get(0); CatoDataObject obj2 = data.get(1); CatoDataObject obj3 = data.get(2); Assert.assertEquals(4, obj1.getFields().size()); Assert.assertEquals(4, obj2.getFields().size()); Assert.assertEquals(4, obj3.getFields().size()); TestUtil.assertEquals(Arrays.asList("Num", "String", "Test", "Digit"), obj1.getFields()); TestUtil.assertEquals(Arrays.asList("Num", "String", "Test", "Digit"), obj2.getFields()); TestUtil.assertEquals(Arrays.asList("Num", "String", "Test", "Digit"), obj3.getFields()); Assert.assertEquals("123", obj1.getValue("Num")); Assert.assertEquals("456", obj2.getValue("Num")); Assert.assertEquals("789", obj3.getValue("Num")); Assert.assertEquals("123", obj1.getValue("Num")); Assert.assertEquals("456", obj2.getValue("Num")); Assert.assertEquals("789", obj3.getValue("Num")); Assert.assertEquals("abcd", obj1.getValue("String")); Assert.assertEquals("efgh", obj2.getValue("String")); Assert.assertEquals("ijkl", obj3.getValue("String")); Assert.assertEquals("test", obj1.getValue("Test")); Assert.assertEquals("test", obj2.getValue("Test")); Assert.assertEquals("tsst", obj3.getValue("Test")); Assert.assertEquals("023", obj1.getValue("Digit")); Assert.assertEquals(" 23", obj2.getValue("Digit")); Assert.assertEquals(" 3", obj3.getValue("Digit")); } catch (Exception ex) { ex.printStackTrace(); Assert.fail(); } } |
DelimitedStreamDataSource extends AbstractStreamDataSource { public String getDelimiter() { return this.delimiter; } DelimitedStreamDataSource(String name, Reader reader, String delimiter); DelimitedStreamDataSource(String name, Reader reader, List<String> fields, String delimiter); String getDelimiter(); } | @Test public void testDelim() { TestUtil.clearLogged(); DelimitedStreamDataSource dataSource = new DelimitedStreamDataSource("Test", new StringReader(TEST_FILE), "|"); Assert.assertEquals("|", dataSource.getDelimiter()); }
@Test public void testFetchData() { try { DelimitedStreamDataSource dataSource = new DelimitedStreamDataSource( "Test", new StringReader(TEST_FILE), ","); dataSource.setTypeConverter(null); Assert.assertEquals(",", dataSource.getDelimiter()); List<CatoDataObject> data = TestUtil.getData(dataSource); Assert.assertEquals(3, data.size()); CatoDataObject obj1 = data.get(0); CatoDataObject obj2 = data.get(1); CatoDataObject obj3 = data.get(2); Assert.assertEquals("123", obj1.getValue("Num")); Assert.assertEquals("456", obj2.getValue("Num")); Assert.assertEquals("2", obj3.getValue("Num")); Assert.assertEquals("Test", obj1.getValue("String")); Assert.assertEquals("Test2", obj2.getValue("String")); Assert.assertEquals("Test3 ", obj3.getValue("String")); Assert.assertEquals("Hello", obj1.getValue("Other")); Assert.assertEquals("This is a long string", obj2.getValue("Other")); Assert.assertEquals("Other Test", obj3.getValue("Other")); } catch (Exception ex) { ex.printStackTrace(); Assert.fail(); } } |
AliasField extends AbstractDerivedField<Object> { protected Object getValue(Object sourceValue) { return sourceValue; } AliasField(String sourceField, String targetField); } | @Test public void testGetValue() throws Exception { Assert.assertEquals("New Field", this.field.getName()); Assert.assertEquals("abc", this.field.getValue("abc")); org.junit.Assert.assertEquals(123, this.field.getValue(123)); org.junit.Assert.assertEquals(new Integer(100), new Integer(100)); } |
UpperCaseField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { return sourceValue.toUpperCase(); } UpperCaseField(String field); UpperCaseField(String sourceField, String targetField); } | @Test public void testGetValue() throws Exception { Assert.assertEquals("ABC", this.field.getValue("abc")); org.junit.Assert.assertEquals("ABC", this.field.getValue("aBc")); org.junit.Assert.assertEquals("ABC123!@#$%^&*()-+`EFG=", this.field.getValue("Abc123!@#$%^&*()-+`efG=")); } |
DoubleField extends AbstractDerivedField<String> { public DoubleField(String field) { this(field, true); } DoubleField(String field); DoubleField(String field, boolean allowBlanks); DoubleField(String sourceField, String targetField); DoubleField(String sourceField, String targetField, boolean allowBlanks); } | @Test public void doubleFieldTest() { DoubleField field1 = new DoubleField("Field", true); Assert.assertEquals("Field", field1.getName()); assertNull(field1.getValue("")); assertNull(field1.getValue(" ")); Assert.assertEquals(5.0, field1.getValue("5")); Assert.assertEquals(3.14, field1.getValue("3.14")); Assert.assertEquals(500.0, field1.getValue("5E2")); try { field1.getValue("abc"); Assert.fail(); } catch (Exception ex) { } DoubleField field2 = new DoubleField("Field", false); try { field2.getValue(" "); org.junit.Assert.fail(); } catch (Exception ex) { } } |
DelimitedField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { StringTokenizer tokenizer = new StringTokenizer(sourceValue, this.delim); List<String> tokens = new ArrayList<String>(); while (tokenizer.hasMoreTokens()) { tokens.add(tokenizer.nextToken().trim()); } Collections.sort(tokens); StringBuilder value = new StringBuilder(); for (String token : tokens) { value.append(token).append(this.delim); } return tokens.size() > 0 ? value.substring(0, value.length() - this.delim.length()) : value.toString(); } DelimitedField(String field, String delim); private DelimitedField(String sourceField, String targetField, String delim); } | @Test public void testGetValue() throws Exception { Assert.assertEquals("a,b,cde", this.field1.getValue("cde,b,a")); org.junit.Assert.assertEquals("a,b,c", this.field1.getValue(" c , b , a ")); org.junit.Assert.assertEquals("abc", this.field1.getValue("abc")); org.junit.Assert.assertEquals("", this.field1.getValue("")); org.junit.Assert.assertEquals("a|b|c", this.field2.getValue("c|b|a")); org.junit.Assert.assertEquals("a|b|c", this.field2.getValue(" c | b | a ")); org.junit.Assert.assertEquals("a", this.field2.getValue("a")); } |
DateField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { try { return this.dateFormat.parse(sourceValue); } catch (ParseException ex) { LOG.error("Failed to parse date '{}'", sourceValue); return sourceValue; } } DateField(String field, String format); DateField(String sourceField, String targetField, String format); } | @Test public void testGetValue() throws Exception { Assert.assertEquals("not a date", this.field.getValue("not a date")); org.junit.Assert.assertEquals(Date.class, this.field.getValue("05-12-2010").getClass()); org.junit.Assert.assertEquals(new SimpleDateFormat("MM-dd-yyyy").parse("05-12-2010"), this.field.getValue("05-12-2010")); } |
AbstractDerivedField implements CatoDerivedField { AbstractDerivedField(String field, Class<T> clazz) { this(field, field, clazz); } AbstractDerivedField(String field, Class<T> clazz); AbstractDerivedField(String sourceField, String targetField, Class<T> clazz); final String getName(); final Object getValue(CatoDataObject obj); } | @Test public void testAbstractDerivedField() { Assert.assertEquals("New Test", field1.getName()); CatoDataObject obj1 = TestUtil.createDataObject("A", "B", 1, 2, 3); Assert.assertEquals("A decorated", field1.getValue(obj1)); CatoDataObject obj2 = TestUtil.createDataObject(null, "B", 1, 2, 3); assertNull(field1.getValue(obj2)); CatoDataObject obj3 = TestUtil.createDataObject("A", "B", 1, 2, 3); org.junit.Assert.assertEquals(1, field2.getValue(obj3)); CatoDataObject obj4 = TestUtil.createDataObject("A", "B", new Date(), 2, 3); org.junit.Assert.assertEquals(String.class, field2.getValue(obj4).getClass()); CatoDataObject obj5 = TestUtil.createDataObject("A", "B", new Timestamp(1000), 2, 3); org.junit.Assert.assertEquals(String.class, field2.getValue(obj5).getClass()); CatoDataObject obj6 = TestUtil.createDataObject("A", "B", true, 2, 3); org.junit.Assert.assertEquals(true, field2.getValue(obj6)); CatoDataObject obj7 = TestUtil.createDataObject("A", "B", new Object(), 2, 3); org.junit.Assert.assertEquals(Object.class, field2.getValue(obj7).getClass()); } |
AbstractCatoDataSource implements CatoDataSource { public final CatoDataObject next() { if (!this.open || this.closed) { throw new UnsupportedOperationException( "Cannot iterate over a DataSource before calling open() or after calling close()"); } try { CatoDataObject current = this.nextObj; if (this.typeConverter != null) { for (String field : current.getFields()) { current.setValue(field, this.typeConverter.convert(current.getValue(field))); } } for (CatoDerivedField field : this.derivedFields) { current.setValue(field.getName(), field.getValue(current)); } this.nextObj = this.nextDataObject(); this.count++; return current; } catch (Exception ex) { throw new RuntimeException("Failed to get next DataObject at row # " + this.count + " in the source", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); } | @Test public void testNextBeforeOpen() { try { this.source.next(); Assert.fail(); } catch (Exception ex) { TestUtil.assertException("Cannot iterate over a DataSource", UnsupportedOperationException.class, ex); } } |
AbstractCatoDataSource implements CatoDataSource { public final void close() { try { if (!this.open) { throw new UnsupportedOperationException("DataSource is not open"); } if (this.closed) { throw new UnsupportedOperationException("DataSource is already closed"); } LOG.info("Closing DataSource {}", this.name); this.closeSource(); this.closed = true; this.open = false; } catch (Exception ex) { throw new RuntimeException("Could not close DataSource '" + this.name + "'", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); } | @Test public void testCloseBeforeOpen() { try { this.source.close(); org.junit.Assert.fail(); } catch (Exception ex) { TestUtil.assertException("is not open", UnsupportedOperationException.class, ex.getCause()); } } |
AbstractCatoDataSource implements CatoDataSource { @Override public final void open() { try { if (this.open) { throw new UnsupportedOperationException("DataSource is already open"); } if (this.closed) { throw new UnsupportedOperationException("DataSource is already closed"); } LOG.info("Opening DataSource {}", this.name); this.openSource(); this.open = true; this.nextObj = this.nextDataObject(); } catch (Exception ex) { throw new RuntimeException("Could not open DataSource '" + this.name + "'", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); } | @Test public void testOpenAfterOpen() { this.source.open(); try { this.source.open(); org.junit.Assert.fail(); } catch (Exception ex) { TestUtil.assertException("is already open", UnsupportedOperationException.class, ex.getCause()); } } |
CatoTypeConverters { public static CatoTypeConverter newCustomTypeConverter(final Function<Object, Object> customConvertor) { return new CatoTypeConverter() { @Override public Object convert(Object data) { return customConvertor.valueOf(data); } }; } static CatoTypeConverter newStringType(); static CatoTypeConverter newStringType(String... dateFormats); static CatoTypeConverter newStringType(int precision, String... dateFormats); static CatoTypeConverter newPreciseDoubleStringType(int precision, String... dateFormats); static CatoTypeConverter newCustomTypeConverter(final Function<Object, Object> customConvertor); } | @Test public void testCustomConversion() { Function converter = new Function() { @Override public Object valueOf(Object arg0) { return (String) arg0 + "-custom"; } }; org.junit.Assert.assertEquals("string-custom", CatoTypeConverters.newCustomTypeConverter(converter).convert("string")); } |
StringTypeConverter extends SimpleTypeConverter { public Object convert(Object value) { if (value == null) { return value; } if (!(value instanceof String)) { return value; } Object str = this.handleString(value); return str; } StringTypeConverter(int precision, String... dateFormats); StringTypeConverter(String... dateFormats); Object convert(Object value); void sethPrecision(int precision); } | @Test public void trivialConvertTest() { assertNull(this.converter.convert(null)); this.assertConvert(Boolean.class, true, true); Object obj = new Object(); this.assertConvert(Object.class, obj, obj); this.assertConvert(String.class, "abc", "abc"); this.assertConvert(String.class, "true2", "true2"); assertNull(this.converter.convert("")); assertNull(this.converter.convert(" ")); assertNull(this.converter.convert(" ")); } |
TextComparisonWriter extends AbstractComparisonWriter { @Override public void close() throws IOException { this.contentWriter.closeWriter(); } TextComparisonWriter(String fileName); TextComparisonWriter(File file); private TextComparisonWriter(File file, boolean writeBreaks); @Override void close(); } | @Test public void testWriter() throws Exception { CatoDataSource dataSource1 = CatoBaseUtil.createDelimitedStreamDataSource("test1", new FileReader("src/test/resources/testdata1.txt"), TestUtil.ALL_FIELDS, ","); CatoDataSource dataSource2 = CatoBaseUtil.createDelimitedStreamDataSource("test2", new FileReader("src/test/resources/testdata2.txt"), TestUtil.ALL_FIELDS, ","); CatoComparison comparison = CatoBaseUtil.compare("Test Comp", dataSource1, dataSource2, TestUtil.KEY_FIELDS, TestUtil.EXCLUDE_FIELDS); TextComparisonWriter writer = new TextComparisonWriter("target/comparisons/text-test.txt"); writer.writeComparison(comparison); writer.close(); Assert.assertTrue(new File("target/comparisons/text-test.txt").canRead()); } |
HTMLComparisonWriter extends AbstractMultiComparisonWriter { public void close() throws IOException { if (this.contentFileName != null) { Writer cwriter = new OutputStreamWriter( IoUtil.getOutputStream(new File(this.contentFileName))); cwriter.write(this.contentWriter.getHtmlString().toString()); cwriter.close(); } if (this.summaryContentFileName != null) { Writer swriter = new OutputStreamWriter( IoUtil.getOutputStream(this.summaryContentFileName)); swriter.write(this.summaryContentWriter.getHtmlString().toString()); swriter.close(); } } HTMLComparisonWriter(String contentfile, String summaryContentFile); private HTMLComparisonWriter(String contentfile, String summaryContentFile,
boolean writeSummary, boolean writeLegend, boolean writeBreaks,
boolean writeDataSets); HTMLComparisonWriter(); private HTMLComparisonWriter(boolean writeSummary, boolean writeLegend,
boolean writeBreaks, boolean writeDataSets); void close(); String getContent(); String getSummaryContent(); } | @Test public void testWriter() throws Exception { CatoDataSource dataSource1 = CatoBaseUtil.createDelimitedStreamDataSource( "test1", new FileReader("src/test/resources/testdata1.txt"), TestUtil.ALL_FIELDS, ","); CatoDataSource dataSource2 = CatoBaseUtil.createDelimitedStreamDataSource( "test2", new FileReader("src/test/resources/testdata2.txt"), TestUtil.ALL_FIELDS, ","); CatoComparison comparison = CatoBaseUtil.compare("HTML Comp", dataSource1, dataSource2, TestUtil.KEY_FIELDS, TestUtil.EXCLUDE_FIELDS); HTMLComparisonWriter writer = new HTMLComparisonWriter( "target/comparisons/html-test-content.html", "target/comparisons/html-test-summary.html"); writer.writeComparison(comparison); writer.close(); Assert.assertTrue(new File("target/comparisons/html-test-content.html") .canRead()); org.junit.Assert.assertTrue(new File("target/comparisons/html-test-summary.html") .canRead()); } |
TableSyncher { private void syncSchemaTables(DbPlatform dbPlatform, RichIterable<TableSyncSide> syncSides, File outputDir) { for (TableSyncSide syncSide : syncSides) { syncSide.enrichTables(dbPlatform); } RichIterable<DaTable> idealTables = this.createIdealTables(syncSides); MapIterable<String, DaTable> idealTablesMap = idealTables.groupByUniqueKey(DaNamedObject.TO_NAME); System.out.println("Starting the alters"); for (TableSyncSide syncSide : syncSides) { for (DaTable table : syncSide.getTables()) { File outputFile = new File(new File(outputDir, syncSide.getSchema().getPhysicalName()), table.getName() + ".sql"); this.generateDiffsToTable(table, idealTablesMap.get(table.getName()), outputFile); } } } static void main(String[] argsArr); void execute(DbFileMergerArgs args); } | @Test public void testSyncSchemaTables() throws Exception { TableSyncher.main(("-dbMergeConfigFile " + "src/test/resources/scenariotests/reveng-merge/merge-config-with-correction.txt " + "-outputDir ./target/merge/unittest").split(" ")); } |
AquaRevengMain { static String extractName(String objectName, String nameCombinePattern) { if (nameCombinePattern != null) { String patternStr = nameCombinePattern.replace("{}", "(.*)"); Pattern namePattern = Pattern.compile(patternStr); Matcher nameMatcher = namePattern.matcher(objectName); if (nameMatcher.matches()) { return nameMatcher.group(1); } } return objectName; } void execute(AquaRevengArgs args); } | @Test public void testExtractName() { assertEquals("TABLE", AquaRevengMain.extractName("TABLE", null)); assertEquals("TABLE", AquaRevengMain.extractName("TABLE", "abca")); assertEquals("TABLE", AquaRevengMain.extractName("TABLE", "abc{}a")); assertEquals("TABLE", AquaRevengMain.extractName("abcTABLEa", "abc{}a")); assertEquals("TABLE", AquaRevengMain.extractName("TABLEaaa", "{}aaa")); assertEquals("TABLE", AquaRevengMain.extractName("aaaTABLE", "aaa{}")); } |
DateFormatterPostParsedSqlTranslator implements PostParsedSqlTranslator { @Override public String handleAnySqlPostTranslation(String string, ChangeInput change) { Matcher matcher = this.datetimeConstantPattern.matcher(string); while (matcher.find()) { String dateConstant = matcher.group(1); for (ThreadLocal<DateFormat> inputFormat : this.dateFormats) { try { Date date = inputFormat.get().parse(dateConstant); if (date == null) { continue; } string = string.replace(dateConstant, COMMON_OUTPUT_DATE_FORMAT.get().format(date)); break; } catch (ParseException e) { continue; } } } return string; } DateFormatterPostParsedSqlTranslator(ImmutableList<String> dateFormatStrings); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); } | @Test public void testDateConversion() { String translated = this.translator.handleAnySqlPostTranslation("start default '9999-12-01-23.12.01.123' end", null); assertEquals("start default '9999-12-01 23:12:01.123' end", translated); translated = this.translator.handleAnySqlPostTranslation("start default '9999-12-01-23.12.01.000000' end", null); assertEquals("start default '9999-12-01 23:12:01.000' end", translated); } |
RemoveWithPreParsedSqlTranslator implements PreParsedSqlTranslator { @Override public String preprocessSql(String sql) { Matcher withMatcher = this.withPattern.matcher(sql); if (withMatcher.find()) { sql = withMatcher.replaceAll(""); } return sql; } @Override String preprocessSql(String sql); } | @Test public void testPreprocessSql() throws Exception { assertEquals( "\tPRIMARY KEY (idField)\n" + "\n" + ") LOCK DATAROWS\n", this.translator.preprocessSql( "\tPRIMARY KEY (idField)\n" + "\tWITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" )); assertEquals( "\tPRIMARY KEY (idField)\n" + "\tSOMETHINGBEFORE_DONTREMOVE WITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" , this.translator.preprocessSql( "\tPRIMARY KEY (idField)\n" + "\tSOMETHINGBEFORE_DONTREMOVE WITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" )); } |
DefaultUnparsedSqlTranslator implements UnparsedSqlTranslator { @Override public String handleRawFullSql(String string, ChangeInput change) { string = this.applyUnsupportedCommandPatterns(string); string = string.replaceAll("(?i)create[ \t]+sequence", "create sequence"); if (string.trim().toUpperCase().startsWith("CREATE SEQUENCE")) { string = string.replaceAll("(?i)as[ \t]+[a-zA-Z]+[ \t]*[\n\r]*[ \t]*start", "start"); string = string.replaceAll("(?i)maxvalue[ \t]+[-0-9]+", ""); string = string.replaceAll("(?i)minvalue[ \t]+[-0-9]+", ""); string = string.replaceAll("(?i)no[ \t]+maxvalue", ""); string = string.replaceAll("(?i)no[ \t]+minvalue", ""); string = string.replaceAll("(?i)no[ \t]+cycle", ""); string = string.replaceAll("(?i)no[ \t]+order", ""); string = string.replaceAll("(?i)order", ""); } string = string.replaceAll("(?i)grant.*(insert|select|update|delete|usage|alter|index|references|control).*", ""); string = string.replaceAll("(?i)revoke.*(insert|select|update|delete|usage|alter|index|references|control).*", ""); string = string.replaceAll("TO GROUP", "TO"); string = string.replaceAll("TO USER", "TO"); return string; } @Override String handleRawFullSql(String string, ChangeInput change); } | @Test public void testRemoveGrantGrant() { assertThat(this.translator.handleRawFullSql("GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE_C TO GROUP GROUP1", null), Matchers.equalToIgnoringWhiteSpace("")); }
@Test public void testCommentGrantFalsePositive() { assertThat(this.translator.handleRawFullSql("blah blah 'SILVER GRANT' blah hello world", null), Matchers.equalToIgnoringWhiteSpace("blah blah 'SILVER GRANT' blah hello world")); } |
DbFileMerger { public static void main(String[] argsArr) { DbFileMergerArgs args = new ArgsParser().parse(argsArr, new DbFileMergerArgs()); new DbFileMerger().execute(args); } static void main(String[] argsArr); void execute(DbFileMergerArgs args); } | @Test public void basicMergeTest() { FileUtils.deleteQuietly(new File("./target/merge/unittest")); DbFileMerger.main(("-dbMergeConfigFile src/test/resources/scenariotests/reveng-merge/merge-config.txt " + "-outputDir ./target/merge/unittest").split(" ")); DirectoryAssert.assertDirectoriesEqual( new File("./src/test/resources/scenariotests/reveng-merge/expected") , new File("./target/merge/unittest") ); }
@Test public void inputValidationTest() { thrown.expectCause(hasMessage(containsString("db1.inputDir file (use forward-slash"))); thrown.expectCause(hasMessage(containsString("db2.inputDir file"))); FileUtils.deleteQuietly(new File("./target/merge/unittest")); DbFileMerger.main(("-dbMergeConfigFile src/test/resources/scenariotests/reveng-merge/merge-config-inputerror.txt " + "-outputDir ./target/merge/unittest").split(" ")); } |
BaselineTableChangeParser implements DbChangeFileParser { @Override public ImmutableList<ChangeInput> value(final ChangeType defaultChangeType, final FileObject file, String fileContent, final String objectName, final String schema, TextMarkupDocumentSection packageMetadata) { MutableList<String> sqls = MultiLineStringSplitter.createSplitterOnSpaceAndLine("GO").valueOf(fileContent); sqls = sqls.reject(Predicates.attributePredicate(StringFunctions.trim(), StringPredicates.empty())); MutableList<String> sortedSqls = this.sortSqls(sqls); MutableList<ChangeInput> changes = sortedSqls.zipWithIndex().collect( new Function<Pair<String, Integer>, ChangeInput>() { @Override public ChangeInput valueOf(Pair<String, Integer> object) { String content = object.getOne(); int index = object.getTwo(); ChangeType changeType = getChangeType(content, defaultChangeType); String changeName = "baseline-change-" + index; boolean active = true; String rollbackIfAlreadyDeployedCommand = null; String rollbackContent = null; ChangeInput change = new ChangeInput(false); change.setChangeKey(new ChangeKey(schema, changeType, objectName, changeName)); change.setOrder(index); change.setContentHash(contentHashStrategy.hashContent(content)); change.setContent(content); change.setRollbackIfAlreadyDeployedContent(rollbackIfAlreadyDeployedCommand); change.setActive(active); change.setRollbackContent(rollbackContent); change.setFileLocation(file); return change; } }); return changes.toImmutable(); } BaselineTableChangeParser(ChangeType fkChangeType, ChangeType triggerChangeType); @Override ImmutableList<ChangeInput> value(final ChangeType defaultChangeType, final FileObject file, String fileContent, final String objectName, final String schema, TextMarkupDocumentSection packageMetadata); } | @Test public void testValue() throws Exception { ChangeType tableChangeType = mock(ChangeType.class); ChangeType fkChangeType = mock(ChangeType.class); ChangeType triggerChangeType = mock(ChangeType.class); BaselineTableChangeParser parser = new BaselineTableChangeParser(fkChangeType, triggerChangeType); ImmutableList<ChangeInput> changes = parser.value( tableChangeType, null, "CREATE TABLE TABLE_A (\n" + "\tA_ID INT\tNOT NULL,\n" + "\tCOL2 INT NULL,\n" + "\tCOL3 INT NULL\n" + ")\n" + "GO\n" + "ALTER TABLE TABLE_A ADD PRIMARY KEY (A_ID)\n" + "GO\n" + "ALTER TABLE TABLE_A ADD FOREIGN KEY FK_B (B_ID) REFERENCES TABLE_B(B_ID)\n" + "GO\n" + "CREATE INDEX TABLE_A_IND ON TABLE_A(COL2, COL3)\n" + "GO\n" + "ALTER TABLE TABLE_A ADD COLUMN COL10 INT NULL\n" + "GO\n", "TABLE_A", "schema", null); assertEquals(5, changes.size()); assertThat(changes.get(0).getContent(), containsString("CREATE TABLE")); assertThat(changes.get(1).getContent(), containsString("PRIMARY KEY")); assertThat(changes.get(2).getContent(), containsString("CREATE INDEX")); assertThat(changes.get(3).getContent(), containsString("ADD COLUMN")); assertThat(changes.get(4).getContent(), containsString("FOREIGN KEY")); } |
DeepCompareUtil { public MutableCollection<CompareBreak> compareCollections(Class clazz, Collection lefts, Collection rights) { MutableCollection<CompareBreak> breaks = Lists.mutable.empty(); this.compareCollectionsInternal(clazz, lefts, rights, breaks); return breaks; } DeepCompareUtil(MutableCollection<ClassCompareInfo> classCompareInfos); MutableCollection<CompareBreak> compareObjects(Object left, Object right); MutableCollection<CompareBreak> compareCollections(Class clazz, Collection lefts, Collection rights); } | @Test public void testCompare() { ClassCompareInfo c1 = ClassCompareInfo.newBuilder() .setClazz(ParentA.class) .setKeyFunction(ParentA.TO_FIELD1) .addCompareFunction("field2", ParentA.TO_FIELD2) .addCompareFunction("childB", ParentA.TO_CHILD_B) .addCollectionComparisonInfo(new CollectionFieldCompareInfo(ChildC.class, ParentA.TO_CHILD_CS)) .build(); ClassCompareInfo c2 = ClassCompareInfo.newBuilder() .setClazz(ChildB.class) .setKeyFunction(ChildB.TO_FIELD1) .addCompareFunction("field2", ChildB.TO_FIELD2) .build(); ClassCompareInfo c3 = ClassCompareInfo.newBuilder() .setClazz(ChildC.class) .setKeyFunction(ChildC.TO_FIELD1) .addCompareFunction("field2", ChildC.TO_FIELD2) .build(); DeepCompareUtil util = new DeepCompareUtil(Lists.mutable.with(c1, c2, c3)); MutableList<ParentA> lefts = Lists.mutable.with( new ParentA.ParentABuilder().setField1("leftOnly").createParentA() , new ParentA.ParentABuilder().setField1("aMatch").setField2(2).setChildB(new ChildB("bMatch", 100)) .setChildCs(Lists.mutable.with(new ChildC("cMatch1", 200), new ChildC("cMatch2", 201))) .createParentA() , new ParentA.ParentABuilder() .setField1("childDiff") .setField2(2) .setChildB(new ChildB("bMatch", 100)) .setChildCs( Lists.mutable.with(new ChildC("cSame", 200), new ChildC("leftOnly", 201), new ChildC( "Cdiff", 210)) ).createParentA() ); MutableList<ParentA> rights = Lists.mutable.with( new ParentA.ParentABuilder().setField1("rightOnly").createParentA() , new ParentA.ParentABuilder().setField1("aMatch").setField2(2).setChildB(new ChildB("bMatch", 100)) .setChildCs(Lists.mutable.with(new ChildC("cMatch1", 200), new ChildC("cMatch2", 201))) .createParentA() , new ParentA.ParentABuilder() .setField1("childDiff") .setField2(2) .setChildB(new ChildB("bMatch", 100)) .setChildCs( Lists.mutable.with(new ChildC("cSame", 200), new ChildC("rightOnly", 201), new ChildC("Cdiff", 220)) ).createParentA() ); MutableCollection<CompareBreak> compareBreaks = util.compareCollections(ParentA.class, lefts, rights); assertEquals(5, compareBreaks.size()); } |
MultiLineStringSplitter implements Function<String, MutableList<String>> { @Override public MutableList<String> valueOf(String inputString) { inputString += "\n"; MutableList<SqlToken> sqlTokens = this.tokenParser.parseTokens(inputString); sqlTokens = this.collapseWhiteSpaceAndTokens(sqlTokens); MutableList<String> finalSplitStrings = Lists.mutable.empty(); String currentSql = ""; for (SqlToken sqlToken : sqlTokens) { if (sqlToken.getTokenType() == SqlTokenType.COMMENT || sqlToken.getTokenType() == SqlTokenType.STRING) { currentSql += sqlToken.getText(); } else { String pattern = splitOnWholeLine ? "(?i)^" + this.splitToken + "$" : this.splitToken; MutableList<String> splitStrings = Lists.mutable.with(Pattern.compile(pattern, Pattern.MULTILINE).split(sqlToken.getText())); if (splitStrings.isEmpty()) { finalSplitStrings.add(currentSql); currentSql = ""; } else if (splitStrings.size() == 1) { currentSql += sqlToken.getText(); } else { splitStrings.set(0, currentSql + splitStrings.get(0)); if (splitOnWholeLine) { if (splitStrings.size() > 1) { splitStrings.set(0, StringUtils.chomp(splitStrings.get(0))); for (int i = 1; i < splitStrings.size(); i++) { String newSql = splitStrings.get(i); if (newSql.startsWith("\n")) { newSql = newSql.replaceFirst("^\n", ""); } else if (newSql.startsWith("\r\n")) { newSql = newSql.replaceFirst("^\r\n", ""); } if (i < splitStrings.size() - 1) { newSql = StringUtils.chomp(newSql); } splitStrings.set(i, newSql); } } } finalSplitStrings.addAll(splitStrings.subList(0, splitStrings.size() - 1)); currentSql = splitStrings.getLast(); } } } if (!currentSql.isEmpty()) { finalSplitStrings.add(currentSql); } if (finalSplitStrings.getLast().isEmpty()) { finalSplitStrings.remove(finalSplitStrings.size() - 1); } else { finalSplitStrings.set(finalSplitStrings.size() - 1, StringUtils.chomp(finalSplitStrings.getLast())); } return finalSplitStrings; } MultiLineStringSplitter(String splitToken); MultiLineStringSplitter(String splitToken, boolean splitOnWholeLine); static MultiLineStringSplitter createSplitterOnSpaceAndLine(String token); @Override MutableList<String> valueOf(String inputString); } | @Test public void deployMultilinePreservationWithSpaces() { assertEquals(Lists.fixedSize.of(sql1 + "\n\n", sql2), this.splitterWithSplaces.valueOf(sql1 + "\n\n" + "\r\n;\n" + sql2)); }
@Test public void testGo() { assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitterGoWithSplaces.valueOf(sql1 + "\nGO\n" + sql2 + "\nGO\n" + sql3)); }
@Test public void testMixedCaseGo() { assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitterGoWithSplaces.valueOf(sql1 + "\ngO\n" + sql2 + "\n Go \n" + sql3)); }
@Test public void testGoWithSpaces() { assertEquals(Lists.fixedSize.of(sql1 + "\n\n", "\n\n" + sql2, sql3), this.splitterGoWithSplaces.valueOf(sql1 + "\n\n\nGO \n\n\n" + sql2 + "\n GO\n" + sql3)); }
@Test public void deployTestRegularLineBreaks() { assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitter.valueOf(sql1 + "\n;\n" + sql2 + "\n;\n" + sql3)); }
@Test public void deployTestLineBreaksWithCarriage() { assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitter.valueOf(sql1 + "\r\n;\r\n" + sql2 + "\n;\n" + sql3)); }
@Test public void deployTestMixedLineBreaks() { assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitter.valueOf(sql1 + "\n;\r\n" + sql2 + "\r\n;\r\n" + sql3)); assertEquals(Lists.fixedSize.of(sql1, sql2, sql3), this.splitter.valueOf(sql1 + "\r\n;\n" + sql2 + "\r\n;\r\n" + sql3)); }
@Test public void deployMultilinePreservation() { assertEquals(Lists.fixedSize.of(sql1 + "\n\n", sql2), this.splitter.valueOf(sql1 + "\n\n" + "\r\n;\n" + sql2)); }
@Test public void testNoSplitIfLineDoesNotExactlyMatch() { assertEquals(Lists.fixedSize.of(sql1 + "\n ; \n" + sql2, sql2), this.splitter.valueOf(sql1 + "\n ; \n" + sql2 + "\n;\n" + sql2)); }
@Test public void expectFailedSplitOnBackwardsCarriageReturn() { assertFalse(Lists.fixedSize.of(sql1, sql2).equals(this.splitter.valueOf(sql1 + "\n;\n\r" + sql2))); }
@Test public void testComments() { assertEquals(Lists.fixedSize.of("sql1\n continued", "sql2"), this.splitterGoWithSplaces.valueOf("sql1\n continued\nGO\nsql2")); }
@Test public void testScenarioWithStrings() { MutableList<String> sqls = this.splitterGoWithSplaces.valueOf("sql1\n" + "GO\n" + "sql2 '1', '2'\n" + "GO\n" + "sql3 3, '4'\n" + "GO\n"); assertEquals(Lists.fixedSize.of("sql1", "sql2 '1', '2'", "sql3 3, '4'", ""), sqls); }
@Test public void testSingleGoAtEnd() { MutableList<String> sqls = this.splitterGoWithSplaces.valueOf("mysql\ngo"); assertEquals(Lists.fixedSize.of("mysql"), sqls); } |
DAStringUtil { public static String normalizeWhiteSpaceFromStringOld(String content) { if (content == null) { return null; } String[] lines = content.split("\\r?\\n"); MutableList<String> newContent = Lists.mutable.empty(); for (String line : lines) { line = line.trim(); if (!line.isEmpty()) { line = line.replaceAll("\\s+", " "); newContent.add(line.trim()); } } return newContent.makeString(" ").trim(); } static String normalizeWhiteSpaceFromString(String content); static String normalizeWhiteSpaceFromStringOld(String content); static final Predicate<String> STRING_IS_BLANK; } | @Test public void testNormalizeWhiteSpaceFromStringOld() { assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromStringOld(null)); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld(" \r\n ")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld(" \r ")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld("")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld(" ")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld(" \n ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromStringOld(" a \n \n a ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromStringOld(" \t a \n \n \t a \t ")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld("\n \n \t \t\t\t\r\r\n\n")); assertEquals("", DAStringUtil.normalizeWhiteSpaceFromStringOld("\t\t \t\n \t \t\t \r\r\n\n \n ")); assertEquals("abc def ghi j k l", DAStringUtil.normalizeWhiteSpaceFromStringOld("\n abc \n \t def \tghi\t\t\rj\rk\nl\n")); assertEquals("abc def ghi j k l", DAStringUtil.normalizeWhiteSpaceFromStringOld(" \n abc \n \t \n\n\r def \tghi\t\t\rj\r k \nl\n")); } |
LookupIndex implements Index { @Override public boolean accept(String each) { return values.contains(each); } LookupIndex(ImmutableSet<String> values); @Override boolean accept(String each); @Override String toString(); } | @Test public void lookupTest() { LookupIndex lookupIndex = new LookupIndex(Sets.immutable.with("ABC", "123")); Assert.assertTrue(lookupIndex.accept("ABC")); Assert.assertTrue(lookupIndex.accept("123")); Assert.assertFalse(lookupIndex.accept("blah")); Assert.assertFalse(lookupIndex.accept("ABc")); } |
CommentRemover { public static String removeComments(String content, String logMessage) { try { MutableList<SqlToken> sqlTokens = new SqlTokenParser().parseTokens(content); MutableList<SqlToken> nonCommentTokens = sqlTokens.reject(new Predicate<SqlToken>() { @Override public boolean accept(SqlToken it) { return it.getTokenType().equals(SqlTokenType.COMMENT); } }); return nonCommentTokens.collect(new Function<SqlToken, String>() { @Override public String valueOf(SqlToken sqlToken) { return sqlToken.getText(); } }).makeString(" "); } catch (TokenMgrError e) { LOG.warn("Error in removing comments from [{}] due to a parsing error (possibly in quote parsing or invalid characters); will default to returning the original string", logMessage, e); return content; } catch (Exception e) { LOG.warn("Error in removing comments from [{}] due to a parsing error (possibly in quote parsing or invalid characters); will default to returning the original string", logMessage, e); return content; } } static String removeComments(String content, String logMessage); } | @Test public void testRemoveComments() { String stringWithoutComment = CommentRemover.removeComments("create procedure sp1\n" + " " -- Comment sp2\n" + " call sp_3(1234) -- end of line comment sp5\n" + " \n" + " sp6 -- ensure that this line still remains (w/ the sp6) between the block comments\n" + " \n" + " call sp4(1234)\n" + "\n" + " "\n" + "\n" + " end\n" + "", "testlog"); assertThat(stringWithoutComment, Matchers.equalToIgnoringWhiteSpace("create procedure sp1\n" + " call sp_3(1234)\n" + " sp6\n" + " call sp4(1234)\n" + " This should not get commented out, as the previous 'start block' was itself commented out\n" + " */\n" + " end")); }
@Test public void testSpecialCharacters() throws Exception { String stringWithoutComment = CommentRemover.removeComments("text合\n" + " " -- Comment 合\n" + " \n" + " text2 合", "testlog"); assertThat(stringWithoutComment, Matchers.equalToIgnoringWhiteSpace("text合 text2 合")); }
@Test public void testReturnGracefullyIfParsingFails() { String content = "abc \"def\" un-closed quote \" un-closed quote"; assertEquals(content, CommentRemover.removeComments(content, "testlog")); }
@Test public void testHandleUnclosedQuoteWithinComments() { String content = "abc \"def\" '1' ghi '2' jkl"; assertThat(CommentRemover.removeComments(content, "testlog"), Matchers.equalToIgnoringWhiteSpace( "abc \"def\" '1' ghi '2' jkl" )); } |
DefaultRollbackDetector implements RollbackDetector { @VisibleForTesting boolean determineRollbackForSchema(final String deployVersion, ImmutableCollection<DeployExecution> deployExecutions) { logDeployExecutions(deployExecutions, "deploy executions"); ImmutableList<DeployExecution> activeDeployments = getActiveDeployments(deployExecutions); logDeployExecutions(activeDeployments, "filtered active deploy executions"); if (activeDeployments == null || activeDeployments.isEmpty()) { return false; } if (getDeployVersion(activeDeployments.getLast()).equals(deployVersion)) { return false; } ImmutableList<DeployExecution> deploymentsExcludingTheLast = activeDeployments.subList(0, activeDeployments.size() - 1); ImmutableList<DeployExecution> rollbackIndicativeDeployments = deploymentsExcludingTheLast.select(new Predicate<DeployExecution>() { @Override public boolean accept(DeployExecution pastDeployment) { return getDeployVersion(pastDeployment).equals(deployVersion); } }); logDeployExecutions(rollbackIndicativeDeployments, "deploy executions that indicate a rollback"); return rollbackIndicativeDeployments.notEmpty(); } @Override boolean determineRollback(final String productVersion, final ImmutableSet<String> schemas, final DeployExecutionDao deployExecutionDao); } | @Test public void testDetermineRollbackForSchema() throws Exception { assertFalse("Deploying a new version (w/ no existing versions) is not a rollback", rollbackDetector.determineRollbackForSchema("new version", Sets.immutable.<DeployExecution>empty())); assertFalse("Deploying a new version is not a rollback", rollbackDetector.determineRollbackForSchema("new version", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "c") ))); assertFalse("Deploying the same version as the latest is not a rollback", rollbackDetector.determineRollbackForSchema("c", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "c") ))); assertTrue("Deploying earlier versions is a rollback", rollbackDetector.determineRollbackForSchema("b", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "c") ))); assertTrue("Deploying earlier versions is a rollback", rollbackDetector.determineRollbackForSchema("a", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "c") ))); assertTrue("Deploying earlier versions is a rollback", rollbackDetector.determineRollbackForSchema("b", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "c") , newExecution(6, "c") ))); assertTrue("Deploying earlier versions is a rollback", rollbackDetector.determineRollbackForSchema("b", Sets.immutable.with( newExecution(3, "a") , newExecution(4, "b") , newExecution(5, "b") , newExecution(6, "c") , newExecution(7, "c") ))); } |
DefaultRollbackDetector implements RollbackDetector { @VisibleForTesting ImmutableList<DeployExecution> getActiveDeployments(ImmutableCollection<DeployExecution> deployExecutions) { if (deployExecutions == null) { return Lists.immutable.empty(); } MutableList<DeployExecution> idSortedExecutions = deployExecutions.toSortedListBy(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution) { return deployExecution.getId(); } }); MutableStack<DeployExecution> executionStack = Stacks.mutable.empty(); for (DeployExecution currentExecution : idSortedExecutions) { if (!currentExecution.isRollback()) { executionStack.push(currentExecution); } else { while (true) { if (executionStack.isEmpty()) { throw new IllegalStateException("Found a rollback deployment without the corresponding version: " + getDeployVersion(currentExecution) + ", " + currentExecution); } else { DeployExecution previousExecution = executionStack.pop(); if (getDeployVersion(previousExecution).equals(getDeployVersion(currentExecution))) { executionStack.push(currentExecution); break; } } } } } return executionStack.toList().reverseThis().toImmutable(); } @Override boolean determineRollback(final String productVersion, final ImmutableSet<String> schemas, final DeployExecutionDao deployExecutionDao); } | @Test public void testGetActiveDeploymentsOnEmptyInput() throws Exception { assertEquals(Lists.immutable.empty(), rollbackDetector.getActiveDeployments(null)); assertEquals(Lists.immutable.empty(), rollbackDetector.getActiveDeployments(Lists.immutable.<DeployExecution>empty())); }
@Test public void testGetActiveDeploymentsOnNormalCase() throws Exception { assertEquals(Lists.immutable.with(1L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution1) { return deployExecution1.getId(); } })); assertEquals(Lists.immutable.with(1L, 2L, 3L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") , newExecution(2, "b") , newExecution(3, "c") )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution) { return deployExecution.getId(); } })); }
@Test public void testGetActiveDeploymentsWithRollback() throws Exception { assertEquals(Lists.immutable.with(3L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") , newExecution(2, "b") , newExecution(3, "a", true) )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution1) { return deployExecution1.getId(); } })); assertEquals(Lists.immutable.with(3L, 4L, 5L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") , newExecution(2, "b") , newExecution(3, "a", true) , newExecution(4, "b") , newExecution(5, "c") )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution) { return deployExecution.getId(); } })); }
@Test public void testWithNullVersionNames() throws Exception { assertEquals(Lists.immutable.with(0L, 3L, 7L, 8L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(0, null) , newExecution(1, "a") , newExecution(2, null) , newExecution(3, "a", true) , newExecution(4, "c") , newExecution(5, "d") , newExecution(6, null) , newExecution(7, "c", true) , newExecution(8, null) )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution) { return deployExecution.getId(); } })); }
@Test public void testGetActiveDeploymentsWithManyRollbacks() throws Exception { assertEquals(Lists.immutable.with(3L, 7L, 8L), rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") , newExecution(2, "b") , newExecution(3, "a", true) , newExecution(4, "c") , newExecution(5, "d") , newExecution(6, "e") , newExecution(7, "c", true) , newExecution(8, "e") )).collect(new Function<DeployExecution, Long>() { @Override public Long valueOf(DeployExecution deployExecution) { return deployExecution.getId(); } })); }
@Test(expected = IllegalStateException.class) public void testGetActiveDeploymentsInvalidExtraRollback() throws Exception { rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "illegal", true) )); }
@Test(expected = IllegalStateException.class) public void testGetActiveDeploymentsInvalidExtraRollback2() throws Exception { rollbackDetector.getActiveDeployments(Sets.immutable.with( newExecution(1, "a") , newExecution(2, "b") , newExecution(3, "a", true) , newExecution(4, "c") , newExecution(5, "d") , newExecution(6, "e") , newExecution(7, "illegal", true) , newExecution(8, "e") )); } |
WildcardPatternIndex implements Index { @Override public boolean accept(String each) { return pattern.matcher(each).matches(); } private WildcardPatternIndex(Pattern pattern); WildcardPatternIndex(String patternString); @Override boolean accept(String each); @Override String toString(); } | @Test public void testBasic() { WildcardPatternIndex wildcardPatternIndex = new WildcardPatternIndex("abc%def"); Assert.assertTrue(wildcardPatternIndex.accept("abcdef")); Assert.assertTrue(wildcardPatternIndex.accept("abcFDASFDSdef")); Assert.assertFalse(wildcardPatternIndex.accept("a1bcFDASFDSdef")); } |
PackageMetadataReader { public PackageMetadata getPackageMetadata(String fileContent) { TextMarkupDocument textMarkupDocument = textMarkupDocumentReader.parseString(fileContent, null); TextMarkupDocumentSection metadataSection = textMarkupDocument.findSectionWithElementName(TextMarkupDocumentReader.TAG_METADATA); String packageMetadataContent = textMarkupDocument.getSections() .select(new Predicate<TextMarkupDocumentSection>() { @Override public boolean accept(TextMarkupDocumentSection it) { return it.getName() == null; } }) .toReversed() .collect(new Function<TextMarkupDocumentSection, String>() { @Override public String valueOf(TextMarkupDocumentSection section) { return section.getContent(); } }) .collect(StringFunctions.trim()) .detect(StringPredicates.notEmpty()); ImmutableMap<String, String> sourceEncodingsMap = getSourceEncodings(getConfig(packageMetadataContent)); if (metadataSection != null || sourceEncodingsMap.notEmpty()) { return new PackageMetadata(metadataSection, sourceEncodingsMap); } else { return null; } } PackageMetadataReader(TextMarkupDocumentReader textMarkupDocumentReader); PackageMetadata getPackageMetadata(String fileContent); } | @Test public void testPackageMetadataWithMetadata() { PackageMetadataReader packageMetadataReader = new PackageMetadataReader(new TextMarkupDocumentReader(false)); PackageMetadata packageMetadata = packageMetadataReader.getPackageMetadata("\n\n \n \n" + " "\n"); assertEquals(Maps.immutable.of("k1", "v1", "k2", "v2"), packageMetadata.getMetadataSection().getAttrs()); assertEquals(Sets.immutable.of("toggle1", "toggle2"), packageMetadata.getMetadataSection().getToggles()); assertEquals(Maps.immutable.<String, String>empty(), packageMetadata.getFileToEncodingMap()); }
@Test public void testPackageMetadataWithProperties() { PackageMetadataReader packageMetadataReader = new PackageMetadataReader(new TextMarkupDocumentReader(false)); PackageMetadata packageMetadata = packageMetadataReader.getPackageMetadata("\n\n \n \n" + "sourceEncodings.UTF-8=a1,a2,a3\n" + "sourceEncodings.UTF-16=a4\n" + "otherProps=abc\n" + "\n"); assertNull(packageMetadata.getMetadataSection()); assertEquals(Maps.immutable.of( "a1", "UTF-8", "a2", "UTF-8", "a3", "UTF-8", "a4", "UTF-16" ) , packageMetadata.getFileToEncodingMap()); }
@Test public void testPackageMetadataWithMetadataAndProperties() { PackageMetadataReader packageMetadataReader = new PackageMetadataReader(new TextMarkupDocumentReader(false)); PackageMetadata packageMetadata = packageMetadataReader.getPackageMetadata("\n\n \n \n" + " "sourceEncodings.UTF-8=a1,a2,a3\n" + "sourceEncodings.UTF-16=a4\n" + "otherProps=abc\n" + "\n"); assertEquals(Maps.immutable.of("k1", "v1", "k2", "v2"), packageMetadata.getMetadataSection().getAttrs()); assertEquals(Sets.immutable.of("toggle1", "toggle2"), packageMetadata.getMetadataSection().getToggles()); assertEquals(Maps.mutable.of( "a1", "UTF-8", "a2", "UTF-8", "a3", "UTF-8", "a4", "UTF-16" ) , packageMetadata.getFileToEncodingMap()); } |
TextMarkupDocumentReader { public TextMarkupDocument parseString(String text, final TextMarkupDocumentSection otherSection) { ImmutableList<TextMarkupDocumentSection> textMarkupDocumentSections = this.parseString(text, this.firstLevelElements, true, " if (otherSection != null) { TextMarkupDocumentSection thisSection = textMarkupDocumentSections.detect(it -> Objects.equals(it.getName(), otherSection.getName())); if (thisSection != null) { thisSection.mergeAttributes(otherSection); } else { textMarkupDocumentSections = Lists.mutable.of(otherSection).withAll(textMarkupDocumentSections).toImmutable(); } } return new TextMarkupDocument(textMarkupDocumentSections); } TextMarkupDocumentReader(boolean legacyMode); TextMarkupDocument parseString(String text, final TextMarkupDocumentSection otherSection); static final String TAG_CHANGE; static final String TAG_METADATA; static final String TAG_BODY; static final String TAG_DROP_COMMAND; static final String TAG_ROLLBACK; static final String TAG_ROLLBACK_IF_ALREADY_DEPLOYED; static final String TOGGLE_DISABLE_QUOTED_IDENTIFIERS; static final String ATTR_UPDATE_TIME_COLUMN; static final String ATTR_DEPENDENCIES; static final String ATTR_EXCLUDE_DEPENDENCIES; static final String ATTR_INCLUDE_DEPENDENCIES; static final String ATTR_PRIMARY_KEYS; static final String INCLUDE_ENVS; static final String EXCLUDE_ENVS; static final String INCLUDE_PLATFORMS; static final String EXCLUDE_PLATFORMS; static final String TAG_PERM_SCHEME; } | @Test public void testSingleSection() { TextMarkupDocument doc = textMarkupDocumentReader.parseString( "line1\n" + "line2\r\n" + "line3\n" , null ); ImmutableList<TextMarkupDocumentSection> sections = doc.getSections(); assertEquals(1, sections.size()); this.assertSection(sections.get(0), null, "line1\nline2\r\nline3", UnifiedMap.<String, String>newMap()); }
@Test public void testRegular() { TextMarkupDocument doc = textMarkupDocumentReader.parseString( " " " "line1\n" + "line2\r\n" + "line3\n" + " " "finalcontent\r\n" + " "rollback content\r\n" + " , null ); verifyRegular(doc); }
@Test public void testPackageMetadataWithMetaInOriginal() { TextMarkupDocumentSection packageMetaSection = new TextMarkupDocumentSection(TextMarkupDocumentReader.TAG_METADATA, null, Maps.immutable.of("k1", "v1", "k2ToOverride", "v2Original")); TextMarkupDocument doc = textMarkupDocumentReader.parseString( " "content" , packageMetaSection ); assertSection(doc.getSections().get(0), TextMarkupDocumentReader.TAG_METADATA, null, Maps.immutable.of("k1", "v1", "k2ToOverride", "v2Overriden", "k3", "newv3")); }
@Test public void testRegularWithBlankSections() { TextMarkupDocument doc = textMarkupDocumentReader.parseString( "\n\n\r\n" + " " "\n\n\r\n" + " "line1\n" + "line2\r\n" + "line3\n" + " " "finalcontent\r\n" + " "rollback content\r\n" + " , null ); verifyRegular(doc); }
@Test public void testRegularWithBlankCommentedSections() { TextMarkupDocument doc = textMarkupDocumentReader.parseString( "\n\n\r\n\n" + " " "\n\n\r\n" + " "line1\n" + "line2\r\n" + "line3\n" + " " "finalcontent\r\n" + " "rollback content\r\n" + " , null ); verifyRegular(doc); }
@Test public void testWithExtraContentAtBeginningAndAfterMetadata() { TextMarkupDocument doc = textMarkupDocumentReader.parseString( "blahblahblah\n" + " " "metadataExtra\n" + " "line1\n" + "line2\r\n" + "line3\n" + " " "finalcontent\r\n" + " "rollback content\r\n" + " , null ); ImmutableList<TextMarkupDocumentSection> sections = doc.getSections(); assertEquals(8, sections.size()); this.assertSection(sections.get(0), null, "blahblahblah", UnifiedMap.<String, String>newMap()); this.assertSection(sections.get(1), TextMarkupDocumentReader.TAG_METADATA, null, UnifiedMap.<String, String>newWithKeysValues("k1", "v1", "k2", "v2")); this.assertSection(sections.get(2), TextMarkupDocumentReader.TAG_METADATA, null, UnifiedMap.<String, String>newWithKeysValues("k3", "v3")); this.assertSection(sections.get(3), null, "metadataExtra", UnifiedMap.<String, String>newMap()); this.assertSection(sections.get(4), TextMarkupDocumentReader.TAG_CHANGE, "line1\nline2\r\nline3", UnifiedMap.<String, String>newWithKeysValues("n", "1", "a", "2")); this.assertSection(sections.get(5), TextMarkupDocumentReader.TAG_CHANGE, null, UnifiedMap.<String, String>newWithKeysValues("n", "2"), UnifiedSet.newSetWith("TOGGLEACTIVE")); this.assertSection(sections.get(6), TextMarkupDocumentReader.TAG_CHANGE, "finalcontent", UnifiedMap.<String, String>newWithKeysValues("n", "3")); this.assertSection(sections.get(6).getSubsections().get(0), TextMarkupDocumentReader.TAG_ROLLBACK_IF_ALREADY_DEPLOYED, "rollback content", UnifiedMap.<String, String>newWithKeysValues("n", "3")); this.assertSection(sections.get(7), TextMarkupDocumentReader.TAG_CHANGE, null, UnifiedMap.<String, String>newWithKeysValues("n", "4")); } |
RegexUtil { public static String convertWildcardPatternToRegex(String wildcardPattern) { return wildcardPattern .replace(".", "\\.") .replace("*", ".*") .replace("%", ".*") ; } static String convertWildcardPatternToRegex(String wildcardPattern); static final String WORD_REGEX; static final Pattern SPACE_PATTERN; } | @Test public void testFilter() { Assert.assertTrue(Pattern.compile(RegexUtil.convertWildcardPatternToRegex("dev0*")).matcher("dev0A1") .matches()); Assert.assertTrue(Pattern.compile(RegexUtil.convertWildcardPatternToRegex("dev0%")).matcher("dev0A1") .matches()); } |
TextMarkupDocumentReader { Pair<ImmutableMap<String, String>, ImmutableSet<String>> parseAttrsAndToggles(String line) { MutableMap<String, String> attrs = Maps.mutable.empty(); MutableSet<String> toggles = Sets.mutable.empty(); if (!legacyMode) { List<Token> tokens = TextMarkupParser.parseTokens(line); Token curToken = !tokens.isEmpty() ? tokens.get(0) : null; while (curToken != null && curToken.kind != TextMarkupLineSyntaxParserConstants.EOF) { switch (curToken.kind) { case TextMarkupLineSyntaxParserConstants.WHITESPACE: break; case TextMarkupLineSyntaxParserConstants.QUOTED_LITERAL: case TextMarkupLineSyntaxParserConstants.STRING_LITERAL: if (curToken.next.kind == TextMarkupLineSyntaxParserConstants.ASSIGN) { Token keyToken = curToken; curToken = curToken.next; curToken = curToken.next; switch (curToken.kind) { case TextMarkupLineSyntaxParserConstants.QUOTED_LITERAL: case TextMarkupLineSyntaxParserConstants.STRING_LITERAL: String value = curToken.image; if (value.charAt(0) == '"' && value.charAt(value.length() - 1) == '"') { value = curToken.image.substring(1, curToken.image.length() - 1); } value = value.replaceAll("\\\\\"", "\""); attrs.put(keyToken.image, value); break; case TextMarkupLineSyntaxParserConstants.WHITESPACE: case TextMarkupLineSyntaxParserConstants.EOF: attrs.put(keyToken.image, ""); break; case TextMarkupLineSyntaxParserConstants.ASSIGN: default: throw new IllegalStateException("Not allowed here"); } } else { toggles.add(curToken.image); } break; case TextMarkupLineSyntaxParserConstants.ASSIGN: toggles.add(curToken.image); break; case TextMarkupLineSyntaxParserConstants.EOF: default: throw new IllegalStateException("Should not arise"); } curToken = curToken.next; } } else { String[] args = StringUtils.splitByWholeSeparator(line, " "); for (String arg : args) { if (arg.contains("=")) { String[] attr = arg.split("="); if (attr.length > 2) { throw new IllegalArgumentException("Cannot mark = multiple times in a parameter - " + line); } String attrVal = attr[1]; if (attrVal.startsWith("\"") && attrVal.endsWith("\"")) { attrVal = attrVal.substring(1, attrVal.length() - 1); } attrs.put(attr[0], attrVal); } else if (StringUtils.isNotBlank(arg)) { toggles.add(arg); } } } return Tuples.pair(attrs.toImmutable(), toggles.toImmutable()); } TextMarkupDocumentReader(boolean legacyMode); TextMarkupDocument parseString(String text, final TextMarkupDocumentSection otherSection); static final String TAG_CHANGE; static final String TAG_METADATA; static final String TAG_BODY; static final String TAG_DROP_COMMAND; static final String TAG_ROLLBACK; static final String TAG_ROLLBACK_IF_ALREADY_DEPLOYED; static final String TOGGLE_DISABLE_QUOTED_IDENTIFIERS; static final String ATTR_UPDATE_TIME_COLUMN; static final String ATTR_DEPENDENCIES; static final String ATTR_EXCLUDE_DEPENDENCIES; static final String ATTR_INCLUDE_DEPENDENCIES; static final String ATTR_PRIMARY_KEYS; static final String INCLUDE_ENVS; static final String EXCLUDE_ENVS; static final String INCLUDE_PLATFORMS; static final String EXCLUDE_PLATFORMS; static final String TAG_PERM_SCHEME; } | @Test public void testSimpleLineParsing() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( "attr=1234 attr2=\"5678\" mytog1" ); assertEquals(Maps.mutable.of("attr", "1234", "attr2", "5678"), results.getOne()); assertEquals(Sets.mutable.of("mytog1"), results.getTwo()); }
@Test public void testQuotedSplitWithEqualSign() { String input = "attr=1234 attr2=\"56=78\" mytog1"; if (legacyMode) { try { textMarkupDocumentReader.parseAttrsAndToggles(input); fail("Should have failed here"); } catch (IllegalArgumentException e) { assertThat(e.getMessage(), containsString("Cannot mark = multiple times")); } } else { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles(input); assertEquals(Maps.mutable.of("attr", "1234", "attr2", "56=78"), results.getOne()); assertEquals(Sets.mutable.of("mytog1"), results.getTwo()); } }
@Test public void testQuotedSplitWithEqualSignAndSpace() { String input = "attr=1234 attr2=\"56 = 78\" mytog1"; if (legacyMode) { try { textMarkupDocumentReader.parseAttrsAndToggles(input); fail("Should have failed here"); } catch (ArrayIndexOutOfBoundsException e) { assertThat(e.getMessage(), notNullValue()); } } else { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles(input); assertEquals(Maps.mutable.of("attr", "1234", "attr2", "56 = 78"), results.getOne()); assertEquals(Sets.mutable.of("mytog1"), results.getTwo()); } }
@Test public void testWordEndingInEqualSignWillFailInLegacy() { String input = " attr= abc"; if (legacyMode) { try { textMarkupDocumentReader.parseAttrsAndToggles(input); fail("Should have failed here"); } catch (ArrayIndexOutOfBoundsException expected) { } } else { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles(input); assertEquals(Maps.mutable.of("attr", ""), results.getOne()); assertEquals(Sets.mutable.of("abc"), results.getTwo()); } }
@Test public void testEqualSignInQuoteValueWillFailInLegacy() { String input = " attr=\"abc=123\" "; if (legacyMode) { try { textMarkupDocumentReader.parseAttrsAndToggles(input); fail("Should throw exception here"); } catch (IllegalArgumentException expected) { } } else { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles(input); assertEquals(Maps.mutable.of("attr", "abc=123"), results.getOne()); assertEquals(Sets.mutable.empty(), results.getTwo()); } }
@Test public void testEqualSignAloneWillFailInLegacy() { String input = " a = b "; if (legacyMode) { try { textMarkupDocumentReader.parseAttrsAndToggles(input); fail("Should throw exception here"); } catch (ArrayIndexOutOfBoundsException expected) { } } else { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles(input); assertEquals(Maps.mutable.empty(), results.getOne()); assertEquals(Sets.mutable.of("a", "b", "="), results.getTwo()); } }
@Test public void testQuoteWithinQuotedStringIsPreservedIfNoSpace() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " abc=attr 1234 attr2=\"56\"78\" mytog1 " ); assertEquals(Maps.mutable.of("abc", "attr", "attr2", "56\"78"), results.getOne()); assertEquals(Sets.mutable.of("1234", "mytog1"), results.getTwo()); }
@Test public void testQuoteWithinStringIsStillPreservedEvenIfStringIsntClosedForBackwardsCompatibility() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " =attr 1234 attr2=\"56\"78 mytog1 " ); if (legacyMode) { assertEquals(Maps.mutable.of("", "attr", "attr2", "\"56\"78"), results.getOne()); assertEquals(Sets.mutable.of("1234", "mytog1"), results.getTwo()); } else { assertEquals(Maps.mutable.of("attr2", "\"56\"78"), results.getOne()); assertEquals(Sets.mutable.of("=", "attr", "1234", "mytog1"), results.getTwo()); } }
@Test public void testBehaviorOfStringStartingWithEqualSign() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " e q =attr 1234 attr2=\"5678\"\" \"\"mytog1\" " ); if (legacyMode) { assertEquals(Maps.mutable.of("", "attr", "attr2", "5678\""), results.getOne()); assertEquals(Sets.mutable.of("1234", "\"\"mytog1\"", "e", "q"), results.getTwo()); } else { assertEquals(Maps.mutable.of("attr2", "5678\""), results.getOne()); assertEquals(Sets.mutable.of("=", "attr", "1234", "\"\"mytog1\"", "e", "q"), results.getTwo()); } }
@Test public void testSlash() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " 123 attr=\"abc\\def\" \\ 456=789" ); if (legacyMode) { assertEquals(Maps.mutable.of("attr", "abc\\def", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\"), results.getTwo()); } else { assertEquals(Maps.mutable.of("attr", "abc\\def", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\"), results.getTwo()); } }
@Test public void testSlashWithQuoteNoEscaping2() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " 123 attr=\"abc\\d ef\" \\ 456=789" ); if (legacyMode) { assertEquals(Maps.mutable.of("attr", "\"abc\\d", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\", "ef\""), results.getTwo()); } else { assertEquals(Maps.mutable.of("attr", "abc\\d ef", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\"), results.getTwo()); } }
@Test(expected = RuntimeException.class) public void testConsecutiveEquals() { textMarkupDocumentReader.parseAttrsAndToggles( " 123 attr==val1 b" ); }
@Test public void testSlashWithQuoteNoEscaping() { Pair<ImmutableMap<String, String>, ImmutableSet<String>> results = textMarkupDocumentReader.parseAttrsAndToggles( " 123 attr=\"abc\\\"d ef\" \\ 456=789" ); if (legacyMode) { assertEquals(Maps.mutable.of("attr", "\"abc\\\"d", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\", "ef\""), results.getTwo()); } else { assertEquals(Maps.mutable.of("attr", "abc\"d ef", "456", "789"), results.getOne()); assertEquals(Sets.mutable.of("123", "\\"), results.getTwo()); } } |
PlatformConfigReader { public ImmutableHierarchicalConfiguration readPlatformProperties(RichIterable<String> configPackages) { MutableList<PropertyInput> prioritizedProperties = readConfigPackages(configPackages); validate(prioritizedProperties); prioritizedProperties.sortThisBy(new Function<PropertyInput, Integer>() { @Override public Integer valueOf(PropertyInput propertyInput1) { return propertyInput1.getPriority(); } }).reverseThis(); CombinedConfiguration combinedConfiguration = new CombinedConfiguration(new OverrideCombiner()); for (HierarchicalConfiguration<ImmutableNode> properties : prioritizedProperties.collect(new Function<PropertyInput, HierarchicalConfiguration<ImmutableNode>>() { @Override public HierarchicalConfiguration<ImmutableNode> valueOf(PropertyInput propertyInput) { return propertyInput.getProps(); } })) { combinedConfiguration.addConfiguration(properties); } combinedConfiguration.clearTree(PROP_CONFIG_PRIORITY); return combinedConfiguration; } ImmutableHierarchicalConfiguration readPlatformProperties(RichIterable<String> configPackages); } | @Test public void testValidDefault() { ImmutableHierarchicalConfiguration properties = reader.readPlatformProperties(Lists.immutable.of("PlatformConfigReader/validDefault")); assertEquals("val1", properties.getString("prop1")); assertEquals("val2", properties.getString("prop2")); assertEquals("val3", properties.getString("key3.prop3")); assertEquals("val4", properties.getString("key4.prop4")); assertEquals(4, properties.size()); }
@Test public void testValidWithOverride() { ImmutableHierarchicalConfiguration properties = reader.readPlatformProperties(Lists.immutable.of("PlatformConfigReader/validWithOverride")); assertEquals(4, properties.size()); assertEquals("val1", properties.getString("prop1")); assertEquals("val2Override", properties.getString("prop2")); assertEquals("val3Override", properties.getString("key3.prop3")); assertEquals("val4", properties.getString("key4.prop4")); }
@Test public void testSameFileWarning() { ImmutableHierarchicalConfiguration properties = reader.readPlatformProperties(Lists.immutable.of("PlatformConfigReader/sameFileWarning")); assertEquals(4, properties.size()); assertEquals("val1", properties.getString("prop1")); assertEquals("val2diff", properties.getString("prop2")); assertEquals("val3diff", properties.getString("key3.prop3")); assertEquals("val4", properties.getString("key4.prop4")); }
@Test(expected = IllegalStateException.class) public void testBadMissingDefault() { reader.readPlatformProperties(Lists.immutable.of("PlatformConfigReader/badMissingDefault")); }
@Test(expected = IllegalStateException.class) public void testBadSameFileNameWithSamePriority() { reader.readPlatformProperties(Lists.immutable.of("PlatformConfigReader/badSameFileSamePriority")); } |
AbstractEnvironmentEnricher implements EnvironmentEnricher<E> { @VisibleForTesting static void validateSchemaName(String schemaName) { if (!PATTERN.matcher(schemaName).matches()) { throw new IllegalArgumentException("SchemaName " + schemaName + " does not match regexp " + PATTERN.pattern()); } } @Override ImmutableCollection<E> readSystem(final HierarchicalConfiguration sysCfg, final FileObject sourcePath); @Override E readEnvironment(ImmutableHierarchicalConfiguration combinedConfiguration, FileObject sourcePath); } | @Test public void validSchemaName() { AbstractEnvironmentEnricher.validateSchemaName("AbcDef123_456_98"); }
@Test public void invalidSchemaName() { thrown.expect(IllegalArgumentException.class); AbstractEnvironmentEnricher.validateSchemaName("abc.def"); } |
RerunnableChangeTypeCommandCalculator implements ChangeTypeCommandCalculator { @Override public ImmutableList<ChangeCommand> calculateCommands(ChangeType changeType, RichIterable<ChangePair> changePairs, RichIterable<Change> allSourceChanges, boolean initAllowedOnHashExceptions) { RerunnableObjectInfo rerunnableObjectInfo = changePairs.injectInto(new RerunnableObjectInfo(), new Function2<RerunnableObjectInfo, ChangePair, RerunnableObjectInfo>() { @Override public RerunnableObjectInfo value(RerunnableObjectInfo rerunnableObjectInfo1, ChangePair changePair) { Change source = changePair.getSourceChange(); Change deployed = changePair.getDeployedChange(); if (source == null && deployed == null) { throw new IllegalStateException("This code branch should never happen; either of source or deployed should exist"); } if (source == null && deployed != null) { rerunnableObjectInfo1.addDroppedObject(deployed); } else if (source != null && deployed == null) { rerunnableObjectInfo1.addChangedObject(source); } else if (ObjectUtils.equals(source.getContentHash(), deployed.getContentHash()) || source.getAcceptableHashes().contains(deployed.getContentHash())) { LOG.trace("Nothing to do here; source [{}] and target [{}] match in hash", source, deployed); } else { rerunnableObjectInfo1.addChangedObject(source); } return rerunnableObjectInfo1; } }); return this.processRerunnableChanges(changeType, rerunnableObjectInfo, allSourceChanges); } RerunnableChangeTypeCommandCalculator(GraphEnricher enricher); @Override ImmutableList<ChangeCommand> calculateCommands(ChangeType changeType, RichIterable<ChangePair> changePairs, RichIterable<Change> allSourceChanges, boolean initAllowedOnHashExceptions); } | @Test public void testSimpleViews() { Change view1Dep = new ChangeRerunnable(viewChangeType(), "schema", "viewA", "hash", CONTENT); Change view1Src = new ChangeRerunnable(viewChangeType(), "schema", "viewA", "hashdiff", CONTENT); Change view2Dep = new ChangeRerunnable(viewChangeType(), "schema", "viewB", "samehash", CONTENT); Change view2Src = new ChangeRerunnable(viewChangeType(), "schema", "viewB", "samehash", CONTENT); Change view3Dep = new ChangeRerunnable(viewChangeType(), "schema", "viewC", "deletion", CONTENT); Change view4Src = new ChangeRerunnable(viewChangeType(), "schema", "viewD", "addition", CONTENT); MutableList<Change> allSourceChanges = Lists.mutable.with( view1Src, view2Src, view4Src ); ListIterable<ChangeCommand> changeset = cmdCalc.calculateCommands(viewChangeType(), Lists.mutable.of( new ChangePair(view1Src, view1Dep) , new ChangePair(view2Src, view2Dep) , new ChangePair(null, view3Dep) , new ChangePair(view4Src, null) ), allSourceChanges, false); assertEquals(3, changeset.size()); Verify.assertAnySatisfy(changeset, assertValue(DeployChangeCommand.class, view1Src)); Verify.assertAnySatisfy(changeset, assertValue(DeployChangeCommand.class, view4Src)); Verify.assertAnySatisfy(changeset, assertValue(DropObjectChangeCommand.class, view3Dep)); } |
AseToH2SqlTranslator implements PostColumnSqlTranslator, PostParsedSqlTranslator { @Override public String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table) { sql = sql.replaceAll("(?i)\\bidentity\\s*(\\(.*\\))?", "AUTO_INCREMENT "); return sql; } @Override String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); } | @Test public void testPostColumnIdentity() throws Exception { assertEquals("AUTO_INCREMENT NOT NULL", this.translator.handlePostColumnText("IDENTITY NOT NULL", null, null)); assertEquals(" AUTO_INCREMENT NOT NULL", this.translator.handlePostColumnText(" IDENTITY NOT NULL", null, null)); assertEquals("sometext AUTO_INCREMENT NOT NULL", this.translator.handlePostColumnText("sometext IDENTITY NOT NULL", null, null)); } |
AseToH2SqlTranslator implements PostColumnSqlTranslator, PostParsedSqlTranslator { @Override public String handleAnySqlPostTranslation(String string, ChangeInput change) { Matcher alterTableAlterColumnMatcher = Pattern.compile("(?i)(alter\\s+table\\s+\\w+\\s+alter\\s+column\\s+\\w+\\s+)(.+)").matcher(string); if (alterTableAlterColumnMatcher.find()) { if (!StringUtils.containsIgnoreCase(alterTableAlterColumnMatcher.group(2), "set") && StringUtils.containsIgnoreCase(alterTableAlterColumnMatcher.group(2), "null")) { Matcher nullOrNotNull = Pattern.compile("(?i)(NOT\\s+NULL|NULL)(.*)").matcher(alterTableAlterColumnMatcher.group(2)); if (nullOrNotNull.matches()) { string = alterTableAlterColumnMatcher.group(1) + "SET " + nullOrNotNull.group(1) + nullOrNotNull.group(2); } } } return string; } @Override String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); } | @Test public void testNotNullToSetNotNullTranslation() { assertEquals("Should insert \"SET\" keyword", "ALTER TABLE some_Table ALTER COLUMN abcCol SET NOT NULL", this.translator.handleAnySqlPostTranslation("ALTER TABLE some_Table ALTER COLUMN abcCol NOT NULL", null)); assertEquals("Should insert \"SET\" keyword", "ALTER TABLE some_Table ALTER COLUMN abcCol SET NULL", this.translator.handleAnySqlPostTranslation("ALTER TABLE some_Table ALTER COLUMN abcCol NULL", null)); assertEquals("Should not touch", "ALTER foo some_Table ALTER COLUMN abcCol NOT NULL", this.translator.handleAnySqlPostTranslation("ALTER foo some_Table ALTER COLUMN abcCol NOT NULL", null)); assertEquals("Should not touch", "ALTER TABLE some_Table ALTER FOO abcCol NOT NULL", this.translator.handleAnySqlPostTranslation("ALTER TABLE some_Table ALTER FOO abcCol NOT NULL", null)); assertEquals("Should not touch", "ALTER TABLE some_Table ALTER COLUMN abcCol FoO NULL", this.translator.handleAnySqlPostTranslation("ALTER TABLE some_Table ALTER COLUMN abcCol FoO NULL", null)); assertEquals("Should not touch", "ALTER TABLE some_Table ALTER COLUMN abcCol SET blahh", this.translator.handleAnySqlPostTranslation("ALTER TABLE some_Table ALTER COLUMN abcCol SET blahh", null)); } |
AseRenameTranslator implements UnparsedSqlTranslator { @Override public String handleRawFullSql(String sql, ChangeInput change) { Matcher matcher = SP_RENAME_PATTERN.matcher(sql); if (matcher.find()) { String replacementSql = " ALTER TABLE " + matcher.group(1) + " ALTER COLUMN " + matcher.group(2) + " RENAME TO " + matcher.group(3); return matcher.replaceFirst(replacementSql); } return sql; } @Override String handleRawFullSql(String sql, ChangeInput change); } | @Test public void translateSpRename() throws Exception { assertThat(translator.handleRawFullSql("sp_rename 'mytab.mycol', 'mynewcol'", null), equalToIgnoringWhiteSpace("ALTER TABLE mytab ALTER COLUMN mycol RENAME TO mynewcol")); }
@Test public void translateSpRenameWithOtherText() throws Exception { assertThat(translator.handleRawFullSql("[with surrounding]\t\n[text] sp_rename 'mytab.mycol', 'mynewcol' [before\n\tand after]", null), equalToIgnoringWhiteSpace("[with surrounding] [text] ALTER TABLE mytab ALTER COLUMN mycol RENAME TO mynewcol [before and after]")); } |
AseToHsqlSqlTranslator implements ColumnSqlTranslator, PostColumnSqlTranslator, PostParsedSqlTranslator { @Override public String handleAnySqlPostTranslation(String string, ChangeInput change) { if (change != null && change.getMetadataSection() != null && change.getMetadataSection().isTogglePresent(TextMarkupDocumentReader.TOGGLE_DISABLE_QUOTED_IDENTIFIERS)) { if (!change.getChangeKey().getChangeType().getName().equals(ChangeType.VIEW_STR)) { string = string.replace('"', '\''); } } Matcher varbinaryDefaultMatcher = this.varbinaryDefaultPattern.matcher(string); if (varbinaryDefaultMatcher.find()) { string = varbinaryDefaultMatcher.replaceFirst("varbinary(1)" + varbinaryDefaultMatcher.group(1)); } return string; } @Override String handleAnySqlPostTranslation(String string, ChangeInput change); @Override String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table); @Override CreateTableColumn handleColumn(CreateTableColumn column, CreateTable table); } | @Test public void testVarbinaryChange() { assertEquals("varbinary(1)not null", this.translator.handleAnySqlPostTranslation("varbinary not null", null)); assertEquals("varbinary(32) not null", this.translator.handleAnySqlPostTranslation("varbinary(32) not null", null)); } |
AseToHsqlSqlTranslator implements ColumnSqlTranslator, PostColumnSqlTranslator, PostParsedSqlTranslator { @Override public String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table) { postColumnText = postColumnText.replaceAll("(?i)\\bidentity\\s*(\\(.*\\))?", "GENERATED BY DEFAULT AS IDENTITY "); return postColumnText; } @Override String handleAnySqlPostTranslation(String string, ChangeInput change); @Override String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table); @Override CreateTableColumn handleColumn(CreateTableColumn column, CreateTable table); } | @Test public void testPostColumnIdentity() throws Exception { assertEquals("GENERATED BY DEFAULT AS IDENTITY NOT NULL", this.translator.handlePostColumnText("IDENTITY NOT NULL", null, null)); assertEquals(" GENERATED BY DEFAULT AS IDENTITY NOT NULL", this.translator.handlePostColumnText(" IDENTITY NOT NULL", null, null)); assertEquals("sometext GENERATED BY DEFAULT AS IDENTITY NOT NULL", this.translator.handlePostColumnText("sometext IDENTITY NOT NULL", null, null)); } |
Db2lookReveng extends AbstractDdlReveng { static ImmutableList<RevengPattern> getRevengPatterns() { String schemaNameSubPattern = getSchemaObjectPattern("\"", "\""); NamePatternType namePatternType = RevengPattern.NamePatternType.TWO; return Lists.immutable.with( new RevengPattern(ChangeType.SEQUENCE_STR, namePatternType, "(?i)create\\s+or\\s+replace\\s+sequence\\s+" + schemaNameSubPattern).withPostProcessSql(REPLACE_TABLESPACE).withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.TABLE_STR, namePatternType, "(?i)create\\s+table\\s+" + schemaNameSubPattern).withPostProcessSql(REPLACE_TABLESPACE).withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.TABLE_STR, namePatternType, "(?i)alter\\s+table\\s+" + schemaNameSubPattern + "\\s+add\\s+constraint\\s+" + schemaNameSubPattern + "\\s+foreign\\s+key", 1, 2, "FK").withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.TABLE_STR, namePatternType, "(?i)alter\\s+table\\s+" + schemaNameSubPattern + "\\s+add\\s+constraint\\s+" + schemaNameSubPattern, 1, 2, null).withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.TABLE_STR, namePatternType, "(?i)alter\\s+table\\s+" + schemaNameSubPattern).withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.TABLE_STR, namePatternType, "(?i)create\\s+index\\s+" + schemaNameSubPattern + "\\s+on\\s+" + schemaNameSubPattern, 2, 1, "INDEX").withPostProcessSql(REPLACE_TABLESPACE).withPostProcessSql(REMOVE_QUOTES), new RevengPattern(ChangeType.FUNCTION_STR, namePatternType, "(?i)create\\s+or\\s+replace\\s+function\\s+" + schemaNameSubPattern), new RevengPattern(ChangeType.VIEW_STR, namePatternType, "(?i)create\\s+or\\s+replace\\s+view\\s+" + schemaNameSubPattern), new RevengPattern(ChangeType.SP_STR, namePatternType, "(?i)create\\s+or\\s+replace\\s+procedure\\s+" + schemaNameSubPattern), new RevengPattern(ChangeType.TRIGGER_STR, namePatternType, "(?i)create\\s+or\\s+replace\\s+trigger\\s+" + schemaNameSubPattern) ); } Db2lookReveng(); } | @Test public void testSchemaExtraction() { ImmutableList<RevengPattern> patterns = Db2lookReveng.getRevengPatterns().select(Predicates.attributeEqual(RevengPattern.TO_CHANGE_TYPE, "VIEW")); RevengPattern revengPattern = patterns.get(0); assertEquals("MYVIEW", revengPattern.evaluate("CREATE or REPLACE VIEW SCHEMA.MYVIEW AS ABC DEF GHI").getPrimaryName()); assertEquals("MYVIEW", revengPattern.evaluate("CREATE or REPLACE VIEW \"SCHEMA\".\"MYVIEW\" AS ABC DEF GHI").getPrimaryName()); assertEquals("MYVIEW", revengPattern.evaluate("CREATE or REPLACE VIEW MYVIEW AS ABC DEF GHI").getPrimaryName()); assertEquals("MYVIEW", revengPattern.evaluate("CREATE or REPLACE VIEW \"MYVIEW\" AS ABC DEF GHI").getPrimaryName()); } |
Db2ToH2SqlTranslator implements PostColumnSqlTranslator { @Override public String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table) { Matcher identityMatcher = Db2ToInMemorySqlTranslator.identityPattern.matcher(sql); if (identityMatcher.find()) { return identityMatcher.replaceFirst("auto_increment "); } else { return sql; } } @Override String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table); } | @Test public void testPostColumnIdentity() throws Exception { assertEquals("auto_increment NOT NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20) NOT NULL", null, null)); assertEquals("auto_increment NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20) NULL", null, null)); assertEquals("auto_increment NOT NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY NOT NULL", null, null)); assertEquals("auto_increment NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY NULL", null, null)); assertEquals("auto_increment ", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20)", null, null)); assertEquals("auto_increment ", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY", null, null)); } |
Db2ToHsqlSqlTranslator implements PostColumnSqlTranslator { @Override public String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table) { Matcher identityMatcher = Db2ToInMemorySqlTranslator.identityPattern.matcher(sql); if (identityMatcher.find()) { return identityMatcher.replaceFirst("generated " + identityMatcher.group(1) + " as identity "); } else { return sql; } } @Override String handlePostColumnText(String sql, CreateTableColumn column, CreateTable table); } | @Test public void testPostColumnIdentity() throws Exception { assertEquals("generated BY DEFAULT as identity NOT NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20) NOT NULL", null, null)); assertEquals("generated BY DEFAULT as identity NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20) NULL", null, null)); assertEquals("generated BY DEFAULT as identity NOT NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY NOT NULL", null, null)); assertEquals("generated BY DEFAULT as identity NULL", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY NULL", null, null)); assertEquals("generated BY DEFAULT as identity ", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1, CACHE 20)", null, null)); assertEquals("generated BY DEFAULT as identity ", this.translator.handlePostColumnText("GENERATED BY DEFAULT AS IDENTITY", null, null)); } |
Db2SqlExecutor extends AbstractSqlExecutor { private String getCurrentPathSql(Connection conn) { synchronized (currentPathSqlLock) { if (this.currentPathSql == null) { this.currentPathSql = getCurrentPathSql(conn, this.getJdbcTemplate(), this.env.getPhysicalSchemas()); } } return this.currentPathSql; } Db2SqlExecutor(DataSource ds, DbEnvironment env); @Override void setDataSourceSchema(Connection conn, PhysicalSchema schema); static void executeReorg(JdbcHelper jdbc, Connection conn, PhysicalSchema schema, String table); } | @Test public void testSetPathSqlCreation() { JdbcHelper jdbc = mock(JdbcHelper.class); Connection conn = mock(Connection.class); when(jdbc.query(Matchers.any(Connection.class), Matchers.anyString(), Matchers.<ResultSetHandler<Object>>any())).thenReturn("s3,\"s1\",\"sB\",s2"); LinkedHashSet<PhysicalSchema> schemas = new LinkedHashSet<PhysicalSchema>(Arrays.asList(new PhysicalSchema("sA"), new PhysicalSchema("sB"), new PhysicalSchema("sC"))); assertEquals("set path s3,s1,sB,s2,sA,sC", Db2SqlExecutor.getCurrentPathSql(conn, jdbc, SetAdapter.adapt(schemas).toImmutable())); } |
Db2SqlExecutor extends AbstractSqlExecutor { Pair<PhysicalSchema, String> findTableNameFromException(Exception exception, int errorCode) { String sqlErrorMC = exception.getMessage(); Matcher matcher; switch (errorCode) { case -20054: matcher = PATTERN_20054.matcher(sqlErrorMC); break; case -668: matcher = PATTERN_668.matcher(sqlErrorMC); break; default: throw new IllegalArgumentException("Unhandled error code for reorg message parsing: " + errorCode); } String schemaName; String tableName; if (matcher.find()) { schemaName = matcher.group(1); tableName = matcher.group(2); } else { throw new IllegalArgumentException("Could not parse the schema/table names for error code " + errorCode + " and message: " + sqlErrorMC); } return Tuples.pair(PhysicalSchema.parseFromString(schemaName), tableName); } Db2SqlExecutor(DataSource ds, DbEnvironment env); @Override void setDataSourceSchema(Connection conn, PhysicalSchema schema); static void executeReorg(JdbcHelper jdbc, Connection conn, PhysicalSchema schema, String table); } | @Test public void testFindTableNameFromSQLException20054WithSpace() { SQLException diagnosable = mock(SQLException.class); when(diagnosable.getMessage()).thenReturn("DB2 SQL error: SQLCODE: -20054, SQLSTATE: 55019, SQLERRMC: _MY_SCHEMA.MYTAB1_;23"); assertEquals(Tuples.pair(new PhysicalSchema("_MY_SCHEMA"), "MYTAB1_"), this.executor.findTableNameFromException(diagnosable, -20054)); verify(diagnosable, times(1)).getMessage(); }
@Test public void testFindTableNameFromSQLException20054() { SQLException diagnosable = mock(SQLException.class); when(diagnosable.getMessage()).thenReturn("DB2 SQL error: SQLCODE: -20054, SQLSTATE: 55019, SQLERRMC=MY_SCHEMA.MYTAB1_;23"); assertEquals(Tuples.pair(new PhysicalSchema("MY_SCHEMA"), "MYTAB1_"), this.executor.findTableNameFromException(diagnosable, -20054)); verify(diagnosable, times(1)).getMessage(); }
@Test public void testFindTableNameFromSQLException668WithSpace() { SQLException diagnosable = mock(SQLException.class); when(diagnosable.getMessage()).thenReturn("DB2 SQL error: SQLCODE: -668, SQLSTATE: 57016, SQLERRMC: 7;7MY_SCHEMA.MYTAB2_"); assertEquals(Tuples.pair(new PhysicalSchema("7MY_SCHEMA"), "MYTAB2_"), this.executor.findTableNameFromException(diagnosable, -668)); verify(diagnosable, times(1)).getMessage(); }
@Test public void testFindTableNameFromSQLException668() { SQLException diagnosable = mock(SQLException.class); when(diagnosable.getMessage()).thenReturn("random prefix - DB2 SQL Error: SQLCODE=-668, SQLSTATE=57016, SQLERRMC=7;MY_SCHEMA.MYTAB3, DRIVER=3.59.81"); assertEquals(Tuples.pair(new PhysicalSchema("MY_SCHEMA"), "MYTAB3"), this.executor.findTableNameFromException(diagnosable, -668)); verify(diagnosable, times(1)).getMessage(); } |
Db2ToInMemorySqlTranslator implements PostColumnSqlTranslator, PostParsedSqlTranslator, UnparsedSqlTranslator { @Override public String handleRawFullSql(String string, ChangeInput change) { return string.replaceAll("(?i)CALL\\s+SYSPROC.*", ""); } @Override String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); @Override String handleRawFullSql(String string, ChangeInput change); static final ImmutableList<String> ACCEPTED_DATE_FORMATS; } | @Test public void testremoveProcCalls() { assertThat(this.translator.handleRawFullSql( " call sysproc.admin_cmd ( 'reorg table calc_result_future_merlin_detail' )", null), equalToIgnoringWhiteSpace("")); } |
Db2ToInMemorySqlTranslator implements PostColumnSqlTranslator, PostParsedSqlTranslator, UnparsedSqlTranslator { @Override public String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table) { Matcher defaultMatcher = this.defaultPattern.matcher(postColumnText); while (defaultMatcher.find()) { String nullClause = defaultMatcher.group(1); String defaultClause = defaultMatcher.group(2); postColumnText = defaultMatcher.replaceFirst("DEFAULT " + defaultClause + " " + nullClause); defaultMatcher = this.defaultPattern.matcher(postColumnText); } Matcher loggedMatcher = this.loggedPattern.matcher(postColumnText); if (loggedMatcher.find()) { postColumnText = loggedMatcher.replaceAll(" "); } Matcher compactMatcher = this.compactPattern.matcher(postColumnText); if (compactMatcher.find()) { postColumnText = compactMatcher.replaceAll(" "); } return postColumnText; } @Override String handlePostColumnText(String postColumnText, CreateTableColumn column, CreateTable table); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); @Override String handleRawFullSql(String string, ChangeInput change); static final ImmutableList<String> ACCEPTED_DATE_FORMATS; } | @Test public void testLoggedRemoval() throws Exception { assertEquals(" NOT NULL", this.translator.handlePostColumnText("LOGGED NOT NULL", null, null)); assertEquals(" NOT NULL", this.translator.handlePostColumnText("NOT LOGGED NOT NULL", null, null)); assertEquals("preText NOT NULL", this.translator.handlePostColumnText("preText LOGGED NOT NULL", null, null)); assertEquals("preText NOT NULL", this.translator.handlePostColumnText("preText NOT LOGGED NOT NULL", null, null)); assertEquals("preText bLOGGED NOT NULL", this.translator.handlePostColumnText("preText bLOGGED NOT NULL", null, null)); assertEquals("preText NOT LOGGEDb NOT NULL", this.translator.handlePostColumnText("preText NOT LOGGEDb NOT NULL", null, null)); }
@Test public void testCompactRemoval() throws Exception { assertEquals(" NOT NULL", this.translator.handlePostColumnText("COMPACT NOT NULL", null, null)); assertEquals(" NOT NULL", this.translator.handlePostColumnText("NOT COMPACT NOT NULL", null, null)); assertEquals("preText NOT NULL", this.translator.handlePostColumnText("preText COMPACT NOT NULL", null, null)); assertEquals("preText NOT NULL", this.translator.handlePostColumnText("preText NOT COMPACT NOT NULL", null, null)); assertEquals("preText bCOMPACT NOT NULL", this.translator.handlePostColumnText("preText bCOMPACT NOT NULL", null, null)); assertEquals("preText NOT COMPACTb NOT NULL", this.translator.handlePostColumnText("preText NOT COMPACTb NOT " + "NULL", null, null)); } |
AbstractBreak implements Break { public void setExcluded(boolean excluded) { this.excluded = excluded; } AbstractBreak(CatoDataObject dataObject, CatoDataSide dataSide); CatoDataObject getDataObject(); CatoDataSide getDataSide(); boolean isExcluded(); void setExcluded(boolean excluded); } | @Test public void setExcludedTest() { this.br = new AbstractBreak(AbstractBreakTest.this.obj, CatoDataSide.LEFT) {}; Assert.assertFalse(this.br.isExcluded()); this.br.setExcluded(true); Assert.assertTrue(this.br.isExcluded()); } |
FieldBreak extends AbstractBreak { public Map<String, Object> getFieldBreaks() { return this.fieldBreaks; } FieldBreak(CatoDataObject dataObject, Map<String, Object> fieldBreaks); Map<String, Object> getFieldBreaks(); Set<String> getFields(); void setExcluded(String field, boolean excluded); boolean isExcluded(String field); Object getExpectedValue(String field); Object getActualValue(String field); } | @Test public void testGetFieldBreaks() { Assert.assertEquals(fieldBreaks, br.getFieldBreaks()); } |
FieldBreak extends AbstractBreak { public Set<String> getFields() { return this.fieldBreaks.keySet(); } FieldBreak(CatoDataObject dataObject, Map<String, Object> fieldBreaks); Map<String, Object> getFieldBreaks(); Set<String> getFields(); void setExcluded(String field, boolean excluded); boolean isExcluded(String field); Object getExpectedValue(String field); Object getActualValue(String field); } | @Test public void testGetFields() { TestUtil.assertEquals(TestUtil.ATTR_FIELDS.subList(0, 2), br.getFields()); } |
FieldBreak extends AbstractBreak { public Object getExpectedValue(String field) { return this.fieldBreaks.get(field); } FieldBreak(CatoDataObject dataObject, Map<String, Object> fieldBreaks); Map<String, Object> getFieldBreaks(); Set<String> getFields(); void setExcluded(String field, boolean excluded); boolean isExcluded(String field); Object getExpectedValue(String field); Object getActualValue(String field); } | @Test public void testGetExpectedValue() { Assert.assertEquals(0, br.getExpectedValue(TestUtil.ATTR_FIELDS.get(0))); Assert.assertEquals(1, br.getExpectedValue(TestUtil.ATTR_FIELDS.get(1))); Assert.assertNull(br.getExpectedValue(TestUtil.ATTR_FIELDS.get(2))); Assert.assertNull(br.getExpectedValue(TestUtil.KEY_FIELDS.get(0))); Assert.assertNull(br.getExpectedValue(TestUtil.KEY_FIELDS.get(1))); } |
FieldBreak extends AbstractBreak { public Object getActualValue(String field) { return this.dataObject.getValue(field); } FieldBreak(CatoDataObject dataObject, Map<String, Object> fieldBreaks); Map<String, Object> getFieldBreaks(); Set<String> getFields(); void setExcluded(String field, boolean excluded); boolean isExcluded(String field); Object getExpectedValue(String field); Object getActualValue(String field); } | @Test public void testGetActualValue() { for (String field : TestUtil.ALL_FIELDS) { Assert.assertEquals(obj.getValue(field), br.getActualValue(field)); } } |
FieldBreak extends AbstractBreak { public void setExcluded(String field, boolean excluded) { this.fieldExcludes.put(field, excluded); } FieldBreak(CatoDataObject dataObject, Map<String, Object> fieldBreaks); Map<String, Object> getFieldBreaks(); Set<String> getFields(); void setExcluded(String field, boolean excluded); boolean isExcluded(String field); Object getExpectedValue(String field); Object getActualValue(String field); } | @Test public void setExcludedTest() { Assert.assertFalse(br.isExcluded(TestUtil.ATTR_FIELDS.get(0))); Assert.assertFalse(br.isExcluded(TestUtil.ATTR_FIELDS.get(1))); br.setExcluded(TestUtil.ATTR_FIELDS.get(0), true); Assert.assertTrue(br.isExcluded(TestUtil.ATTR_FIELDS.get(0))); } |
GroupBreak extends AbstractBreak { public Collection<String> getFields() { return this.fields; } GroupBreak(CatoDataObject dataObject, CatoDataSide dataSide, Collection<String> fields, int groupId); Collection<String> getFields(); int getGroupId(); @Override String toString(); } | @Test public void testGetFields() { TestUtil.assertEquals(TestUtil.ATTR_FIELDS.subList(0, 2), br.getFields()); } |
GroupBreak extends AbstractBreak { public int getGroupId() { return this.groupId; } GroupBreak(CatoDataObject dataObject, CatoDataSide dataSide, Collection<String> fields, int groupId); Collection<String> getFields(); int getGroupId(); @Override String toString(); } | @Test public void testGetGroupId() { Assert.assertEquals(1, br.getGroupId()); } |
TarjanLowestCommonAncestor { public V calculate(V start, V a, V b) { List<LcaRequestResponse<V>> list = new LinkedList<LcaRequestResponse<V>>(); list.add(new LcaRequestResponse<V>(a, b)); return calculate(start, list).get(0); } TarjanLowestCommonAncestor(Graph<V, E> g); V calculate(V start, V a, V b); List<V> calculate(V start, List<LcaRequestResponse<V>> lrr); } | @Test public void testBinaryTree() { DirectedGraph<String, DefaultEdge> g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class); g.addVertex("a"); g.addVertex("b"); g.addVertex("c"); g.addVertex("d"); g.addVertex("e"); g.addEdge("a", "b"); g.addEdge("b", "c"); g.addEdge("b", "d"); g.addEdge("d", "e"); Assert.assertEquals("b", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "c", "e")); Assert.assertEquals("b", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "b", "d")); Assert.assertEquals("d", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "d", "e")); }
@Test public void testDag() { DirectedGraph<String, DefaultEdge> g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class); g.addVertex("a"); g.addVertex("b"); g.addVertex("c"); g.addVertex("d"); g.addVertex("e"); g.addVertex("f"); g.addVertex("g"); g.addEdge("a", "b"); g.addEdge("b", "c"); g.addEdge("c", "d"); g.addEdge("d", "f"); g.addEdge("b", "e"); g.addEdge("e", "f"); g.addEdge("f", "g"); Assert.assertEquals("b", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "b", "g")); Assert.assertEquals("b", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "e", "d")); Assert.assertEquals("d", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "f", "d")); LcaRequestResponse<String> bg = new LcaRequestResponse<String>("b", "g"); LcaRequestResponse<String> ed = new LcaRequestResponse<String>("e", "d"); LcaRequestResponse<String> fd = new LcaRequestResponse<String>("f", "d"); List<LcaRequestResponse<String>> list = new LinkedList<LcaRequestResponse<String>> (); list.add(bg); list.add(ed); list.add(fd); List<String> result = new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", list); Assert.assertEquals("b",bg.getLca()); Assert.assertEquals("b",ed.getLca()); Assert.assertEquals("d",fd.getLca()); Assert.assertEquals(Arrays.asList(new String[]{"b","b","d"}),result); Assert.assertEquals("d", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "d", "f")); }
@Test public void testComplexDag() { DirectedGraph<String, DefaultEdge> g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class); g.addVertex("a"); g.addVertex("b"); g.addVertex("c"); g.addVertex("d"); g.addVertex("e"); g.addVertex("f"); g.addVertex("g"); g.addEdge("a", "b"); g.addEdge("b", "c"); g.addEdge("c", "d"); g.addEdge("d", "f"); g.addEdge("b", "e"); g.addEdge("e", "f"); g.addEdge("f", "g"); g.addEdge("a", "f"); Assert.assertEquals("b", new TarjanLowestCommonAncestor<String, DefaultEdge>(g).calculate("a", "e", "c")); } |
GrpcServerHost implements AutoCloseable, ApplicationContextAware { @Override public void setApplicationContext(@Nonnull ApplicationContext applicationContext) throws BeansException { this.applicationContext = Preconditions.checkNotNull(applicationContext); } GrpcServerHost(int port); GrpcServerHost(int port, long shutdownWaitTimeInMillis); GrpcServerHost(int port, long shutdownWaitTimeInMillis, GrpcServerFactory serverFactory); @Override void setApplicationContext(@Nonnull ApplicationContext applicationContext); final int getPort(); void start(); @Override void close(); } | @Test public void constructorSetsFieldsCorrectly() { final int port = ThreadLocalRandom.current().nextInt(1000, 10000); final long shutdownWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1000, 10000); final ApplicationContext applicationContext = mock(ApplicationContext.class); GrpcServerHost runner = new GrpcServerHost(port, shutdownWaitTimeInMillis); runner.setApplicationContext(applicationContext); assertThat(runner.applicationContext).isSameAs(applicationContext); assertThat(runner.port).isEqualTo(port); assertThat(runner.shutdownWaitTimeInMillis).isEqualTo(shutdownWaitTimeInMillis); }
@Test public void startThrowsForBadServices() { final String badService1 = UUID.randomUUID().toString(); final String badService2 = UUID.randomUUID().toString(); final String goodService = UUID.randomUUID().toString(); final int port = ThreadLocalRandom.current().nextInt(1000, 10000); final long shutdownWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1000, 10000); final ApplicationContext applicationContext = mock(ApplicationContext.class); final Map<String, Object> services = ImmutableMap.of( badService1, new Object(), badService2, new Object(), goodService, new GreeterGrpc.GreeterImplBase() { }); when(applicationContext.getBeansWithAnnotation(eq(GrpcService.class))).thenReturn(services); GrpcServerHost runner = new GrpcServerHost(port, shutdownWaitTimeInMillis); runner.setApplicationContext(applicationContext); assertThatThrownBy(runner::start) .isInstanceOf(IllegalStateException.class) .doesNotHave(new Condition<Throwable>( t -> t.getMessage().contains(goodService), "Error should not include good service.")) .hasMessageContaining(badService1) .hasMessageContaining(badService2); } |
Servers { public static Server shutdownGracefully(Server server, long maxWaitTimeInMillis) throws InterruptedException { return shutdownGracefully(server, maxWaitTimeInMillis, TimeUnit.MILLISECONDS); } private Servers(); static Server shutdownGracefully(Server server, long maxWaitTimeInMillis); static Server shutdownGracefully(Server server, long timeout, TimeUnit unit); static Server shutdownWithJvm(Server server, long maxWaitTimeInMillis); } | @Test public void shutdownGracefullyCausesServerToProperlyShutdown() throws Exception { final Server server = mock(Server.class); final long maxWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1, 10000); assertThat(Servers.shutdownGracefully(server, maxWaitTimeInMillis)).isSameAs(server); InOrder inOrder = Mockito.inOrder(server); inOrder.verify(server).shutdown(); inOrder.verify(server).awaitTermination(eq(maxWaitTimeInMillis), eq(TimeUnit.MILLISECONDS)); inOrder.verify(server).shutdownNow(); }
@Test public void shutdownGracefullyPropagatesAwaitInterrupt() throws Exception { final Server server = mock(Server.class); final long maxWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1, 10000); final InterruptedException interruptedException = new InterruptedException(); when(server.awaitTermination(anyLong(), any())).thenThrow(interruptedException); assertThatThrownBy(() -> Servers.shutdownGracefully(server, maxWaitTimeInMillis)) .isSameAs(interruptedException); InOrder inOrder = Mockito.inOrder(server); inOrder.verify(server).shutdown(); inOrder.verify(server).awaitTermination(eq(maxWaitTimeInMillis), eq(TimeUnit.MILLISECONDS)); inOrder.verify(server).shutdownNow(); }
@Test public void shutdownGracefullyThrowsIfServerIsNull() { final long maxWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1, Long.MAX_VALUE); assertThatThrownBy(() -> Servers.shutdownGracefully(null, maxWaitTimeInMillis)) .isInstanceOf(NullPointerException.class) .hasMessageContaining("server"); }
@Test public void shutdownGracefullyThrowsIfMaxWaitTimeInMillisIsZero() { final Server server = mock(Server.class); assertThatThrownBy(() -> Servers.shutdownGracefully(server, 0)) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("timeout must be greater than 0"); }
@Test public void shutdownGracefullyThrowsIfMaxWaitTimeInMillisIsLessThanZero() { final long maxWaitTimeInMillis = ThreadLocalRandom.current().nextLong(Long.MIN_VALUE, 0); final Server server = mock(Server.class); assertThatThrownBy(() -> Servers.shutdownGracefully(server, maxWaitTimeInMillis)) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("timeout must be greater than 0"); } |
LambdaStreamObserver implements StreamObserver<T> { @Override public void onNext(T value) { onNext.accept(value); } LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError, Runnable onCompleted); LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError); LambdaStreamObserver(Consumer<T> onNext); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test public void OnNextDelegatesCorrectly() { AtomicReference<Object> called = new AtomicReference<>(); Object val = new Object(); LambdaStreamObserver<Object> obs = new LambdaStreamObserver<>(called::set, null, null); obs.onNext(val); assertThat(called.get()).isEqualTo(val); } |
LambdaStreamObserver implements StreamObserver<T> { @Override public void onError(Throwable t) { onError.accept(t); } LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError, Runnable onCompleted); LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError); LambdaStreamObserver(Consumer<T> onNext); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test public void OnErrorDelegatesCorrectly() { AtomicReference<Throwable> called = new AtomicReference<>(); Throwable val = new Exception(); LambdaStreamObserver<Object> obs = new LambdaStreamObserver<>(null, called::set, null); obs.onError(val); assertThat(called.get()).isEqualTo(val); } |
LambdaStreamObserver implements StreamObserver<T> { @Override public void onCompleted() { onCompleted.run(); } LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError, Runnable onCompleted); LambdaStreamObserver(Consumer<T> onNext, Consumer<Throwable> onError); LambdaStreamObserver(Consumer<T> onNext); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test public void OnCompletedDelegatesCorrectly() { AtomicBoolean called = new AtomicBoolean(false); LambdaStreamObserver<Object> obs = new LambdaStreamObserver<>(null, null, () -> called.set(true)); obs.onCompleted(); assertThat(called.get()).isTrue(); } |
TransmitUnexpectedExceptionInterceptor implements ServerInterceptor { public TransmitUnexpectedExceptionInterceptor forExactType(Class<? extends Throwable> exactType) { this.exactTypes.add(exactType); return this; } TransmitUnexpectedExceptionInterceptor forExactType(Class<? extends Throwable> exactType); TransmitUnexpectedExceptionInterceptor forExactTypes(Collection<Class<? extends Throwable>> exactTypes); TransmitUnexpectedExceptionInterceptor forParentType(Class<? extends Throwable> parentType); TransmitUnexpectedExceptionInterceptor forParentTypes(Collection<Class<? extends Throwable>> parentTypes); TransmitUnexpectedExceptionInterceptor forAllExceptions(); @Override ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next); } | @Test public void exactTypeMatches() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onError(new ArithmeticException("Divide by zero")); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forExactType(ArithmeticException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); }
@Test public void unknownTypeDoesNotMatch() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onError(new NullPointerException("Bananas!")); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forExactType(ArithmeticException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.UNKNOWN.getCode()), "is Status.UNKNOWN") .hasMessageContaining("UNKNOWN"); }
@Test public void unexpectedExceptionCanMatch() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { throw new ArithmeticException("Divide by zero"); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forExactType(ArithmeticException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); }
@Test public void unexpectedExceptionCanNotMatch() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { throw new ArithmeticException("Divide by zero"); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forExactType(NullPointerException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.UNKNOWN.getCode()), "is Status.UNKNOWN") .hasMessageContaining("UNKNOWN"); }
@Test public void unexpectedExceptionCanMatchStreaming() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHelloStream(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onNext(HelloResponse.getDefaultInstance()); responseObserver.onNext(HelloResponse.getDefaultInstance()); throw new ArithmeticException("Divide by zero"); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forExactType(ArithmeticException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); Iterator<HelloResponse> it = stub.sayHelloStream(HelloRequest.newBuilder().setName("World").build()); it.next(); it.next(); assertThatThrownBy(it::next) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); } |
TransmitUnexpectedExceptionInterceptor implements ServerInterceptor { public TransmitUnexpectedExceptionInterceptor forParentType(Class<? extends Throwable> parentType) { this.parentTypes.add(parentType); return this; } TransmitUnexpectedExceptionInterceptor forExactType(Class<? extends Throwable> exactType); TransmitUnexpectedExceptionInterceptor forExactTypes(Collection<Class<? extends Throwable>> exactTypes); TransmitUnexpectedExceptionInterceptor forParentType(Class<? extends Throwable> parentType); TransmitUnexpectedExceptionInterceptor forParentTypes(Collection<Class<? extends Throwable>> parentTypes); TransmitUnexpectedExceptionInterceptor forAllExceptions(); @Override ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next); } | @Test public void parentTypeMatches() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onError(new ArithmeticException("Divide by zero")); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forParentType(RuntimeException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); }
@Test public void parentTypeMatchesExactly() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onError(new RuntimeException("Divide by zero")); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forParentType(RuntimeException.class); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); } |
TransmitUnexpectedExceptionInterceptor implements ServerInterceptor { public TransmitUnexpectedExceptionInterceptor forAllExceptions() { return forParentType(Throwable.class); } TransmitUnexpectedExceptionInterceptor forExactType(Class<? extends Throwable> exactType); TransmitUnexpectedExceptionInterceptor forExactTypes(Collection<Class<? extends Throwable>> exactTypes); TransmitUnexpectedExceptionInterceptor forParentType(Class<? extends Throwable> parentType); TransmitUnexpectedExceptionInterceptor forParentTypes(Collection<Class<? extends Throwable>> parentTypes); TransmitUnexpectedExceptionInterceptor forAllExceptions(); @Override ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next); } | @Test public void alleMatches() { GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() { @Override public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) { responseObserver.onError(new ArithmeticException("Divide by zero")); } }; ServerInterceptor interceptor = new TransmitUnexpectedExceptionInterceptor().forAllExceptions(); serverRule.getServiceRegistry().addService(ServerInterceptors.intercept(svc, interceptor)); GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(serverRule.getChannel()); assertThatThrownBy(() -> stub.sayHello(HelloRequest.newBuilder().setName("World").build())) .isInstanceOf(StatusRuntimeException.class) .matches(sre -> ((StatusRuntimeException) sre).getStatus().getCode().equals(Status.INTERNAL.getCode()), "is Status.INTERNAL") .hasMessageContaining("Divide by zero"); } |
AggregateClientInterceptor implements ClientInterceptor { @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) { for (ClientInterceptor interceptor : Lists.reverse(interceptors)) { next = new InterceptorChannel(next, interceptor); } return next.newCall(method, callOptions); } AggregateClientInterceptor(ClientInterceptor... interceptors); AggregateClientInterceptor(List<ClientInterceptor> interceptors); @Override ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next); } | @Test public void OneInterceptorIsCalled() { AtomicBoolean interceptorCalled = new AtomicBoolean(false); ClientInterceptor interceptor = new ClientInterceptor() { @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) { interceptorCalled.set(true); return next.newCall(method, callOptions); } }; ClientInterceptor aggregate = new AggregateClientInterceptor(interceptor); StubChannel channel = new StubChannel(); aggregate.interceptCall(null, CallOptions.DEFAULT, channel); assertThat(interceptorCalled.get()).isTrue(); assertThat(channel.called).isTrue(); }
@Test public void TwoInterceptorsAreCalledInOrder() { AtomicBoolean interceptorOneCalled = new AtomicBoolean(false); AtomicBoolean interceptorTwoCalled = new AtomicBoolean(false); ClientInterceptor interceptorOne = new ClientInterceptor() { @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) { interceptorOneCalled.set(true); return next.newCall(method, callOptions); } }; ClientInterceptor interceptorTwo = new ClientInterceptor() { @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) { assertThat(interceptorOneCalled.get()).isTrue(); interceptorTwoCalled.set(true); return next.newCall(method, callOptions); } }; ClientInterceptor aggregate = new AggregateClientInterceptor(interceptorOne, interceptorTwo); StubChannel channel = new StubChannel(); aggregate.interceptCall(null, CallOptions.DEFAULT, channel); assertThat(interceptorOneCalled.get()).isTrue(); assertThat(interceptorTwoCalled.get()).isTrue(); assertThat(channel.called).isTrue(); } |
AggregateServerInterceptor implements ServerInterceptor { @Override public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { for (ServerInterceptor interceptor : Lists.reverse(interceptors)) { next = new InterceptorServerCallHandler<>(next, interceptor); } return next.startCall(call, headers); } AggregateServerInterceptor(ServerInterceptor... interceptors); AggregateServerInterceptor(List<ServerInterceptor> interceptors); @Override ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next); } | @Test public void OneInterceptorIsCalled() { AtomicBoolean interceptorCalled = new AtomicBoolean(false); ServerInterceptor interceptor = new ServerInterceptor() { @Override public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { interceptorCalled.set(true); return next.startCall(call, headers); } }; ServerInterceptor aggregate = new AggregateServerInterceptor(interceptor); StubHandler<Object, Object> handler = new StubHandler<>(); aggregate.interceptCall(null, new Metadata(), handler); assertThat(interceptorCalled.get()).isTrue(); assertThat(handler.called).isTrue(); }
@Test public void TwoInterceptorsAreCalledInOrder() { AtomicBoolean interceptorOneCalled = new AtomicBoolean(false); AtomicBoolean interceptorTwoCalled = new AtomicBoolean(false); ServerInterceptor interceptorOne = new ServerInterceptor() { @Override public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { interceptorOneCalled.set(true); return next.startCall(call, headers); } }; ServerInterceptor interceptorTwo = new ServerInterceptor() { @Override public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { assertThat(interceptorOneCalled.get()).isTrue(); interceptorTwoCalled.set(true); return next.startCall(call, headers); } }; ServerInterceptor aggregate = new AggregateServerInterceptor(interceptorOne, interceptorTwo); StubHandler<Object, Object> handler = new StubHandler<>(); aggregate.interceptCall(null, new Metadata(), handler); assertThat(interceptorOneCalled.get()).isTrue(); assertThat(interceptorTwoCalled.get()).isTrue(); assertThat(handler.called).isTrue(); } |
DefaultDeadlineInterceptor implements ClientInterceptor { @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) { if (callOptions.getDeadline() == null && Context.current().getDeadline() == null) { callOptions = callOptions.withDeadlineAfter(duration.toMillis(), TimeUnit.MILLISECONDS); } return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) { }; } DefaultDeadlineInterceptor(Duration duration); Duration getDuration(); void setDuration(Duration duration); @Override ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next); } | @Test public void interceptorShouldAddDeadlineWhenAbsent() { AtomicBoolean called = new AtomicBoolean(false); DefaultDeadlineInterceptor interceptor = new DefaultDeadlineInterceptor(Duration.ofHours(1)); interceptor.interceptCall(null, CallOptions.DEFAULT, new Channel() { @Override public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) { called.set(true); assertThat(callOptions.getDeadline().timeRemaining(TimeUnit.MINUTES)).isEqualTo(59); return null; } @Override public String authority() { return null; } }); assertThat(called.get()).isTrue(); }
@Test public void interceptorShouldNotModifyExplicitDeadline() { AtomicBoolean called = new AtomicBoolean(false); DefaultDeadlineInterceptor interceptor = new DefaultDeadlineInterceptor(Duration.ofHours(1)); interceptor.interceptCall(null, CallOptions.DEFAULT.withDeadlineAfter(10, TimeUnit.HOURS), new Channel() { @Override public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) { called.set(true); assertThat(callOptions.getDeadline().timeRemaining(TimeUnit.HOURS)).isEqualTo(9); return null; } @Override public String authority() { return null; } }); assertThat(called.get()).isTrue(); }
@Test public void interceptorShouldNotModifyContextDeadline() throws Exception { AtomicBoolean called = new AtomicBoolean(false); DefaultDeadlineInterceptor interceptor = new DefaultDeadlineInterceptor(Duration.ofHours(1)); Context.current().withDeadlineAfter(10, TimeUnit.HOURS, Executors.newSingleThreadScheduledExecutor()).run(() -> { interceptor.interceptCall(null, CallOptions.DEFAULT, new Channel() { @Override public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) { called.set(true); assertThat(callOptions.getDeadline()).isNull(); return null; } @Override public String authority() { return null; } }); }); assertThat(called.get()).isTrue(); } |
GuavaLFReturnValueHandler implements HandlerMethodReturnValueHandler { private int indexOfType(final List<HandlerMethodReturnValueHandler> originalHandlers, Class<?> handlerClass) { for (int i = 0; i < originalHandlers.size(); i++) { final HandlerMethodReturnValueHandler valueHandler = originalHandlers.get(i); if (handlerClass.isAssignableFrom(valueHandler.getClass())) { return i; } } return -1; } @Override boolean supportsReturnType(MethodParameter returnType); @Override void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest); GuavaLFReturnValueHandler install(RequestMappingHandlerAdapter requestMappingHandlerAdapter); } | @Test public void handlerIsRegistered() { List<HandlerMethodReturnValueHandler> handlers = requestMappingHandlerAdapter.getReturnValueHandlers(); assertThat(indexOfType(handlers, GuavaLFReturnValueHandler.class)).isGreaterThanOrEqualTo(0); }
@Test public void handlerIsAfterDeferredResultMethodReturnValueHandler() { List<HandlerMethodReturnValueHandler> handlers = requestMappingHandlerAdapter.getReturnValueHandlers(); int lfHandlerIndex = indexOfType(handlers, GuavaLFReturnValueHandler.class); int drHandlerIndex = indexOfType(handlers, DeferredResultMethodReturnValueHandler.class); assertThat(lfHandlerIndex).isGreaterThan(drHandlerIndex); } |
DefaultCallOptionsClientInterceptor implements ClientInterceptor { @VisibleForTesting CallOptions patchOptions(CallOptions baseOptions) { CallOptions patchedOptions = baseOptions; patchedOptions = patchOption(patchedOptions, CallOptions::getAuthority, CallOptions::withAuthority); patchedOptions = patchOption(patchedOptions, CallOptions::getCredentials, CallOptions::withCallCredentials); patchedOptions = patchOption(patchedOptions, CallOptions::getCompressor, CallOptions::withCompression); patchedOptions = patchOption(patchedOptions, CallOptions::getDeadline, CallOptions::withDeadline); patchedOptions = patchOption(patchedOptions, CallOptions::isWaitForReady, (callOptions, waitForReady) -> waitForReady ? callOptions.withWaitForReady() : callOptions.withoutWaitForReady()); patchedOptions = patchOption(patchedOptions, CallOptions::getMaxInboundMessageSize, CallOptions::withMaxInboundMessageSize); patchedOptions = patchOption(patchedOptions, CallOptions::getMaxOutboundMessageSize, CallOptions::withMaxOutboundMessageSize); patchedOptions = patchOption(patchedOptions, CallOptions::getExecutor, CallOptions::withExecutor); for (ClientStreamTracer.Factory factory : defaultOptions.getStreamTracerFactories()) { patchedOptions = patchedOptions.withStreamTracerFactory(factory); } for (CallOptions.Key<Object> key : customOptionKeys(defaultOptions)) { patchedOptions = patchOption(patchedOptions, co -> co.getOption(key), (co, o) -> co.withOption(key, o)); } return patchedOptions; } DefaultCallOptionsClientInterceptor(CallOptions options); DefaultCallOptionsClientInterceptor overwriteExistingValues(); CallOptions getDefaultOptions(); void setDefaultOptions(CallOptions options); @Override ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next); } | @Test public void simpleValueTransfers() { CallOptions baseOptions = CallOptions.DEFAULT; CallOptions defaultOptions = CallOptions.DEFAULT.withAuthority("FOO"); DefaultCallOptionsClientInterceptor interceptor = new DefaultCallOptionsClientInterceptor(defaultOptions); CallOptions patchedOptions = interceptor.patchOptions(baseOptions); assertThat(patchedOptions.getAuthority()).isEqualTo("FOO"); }
@Test public void clientStreamTracerTransfers() { ClientStreamTracer.Factory factory1 = new ClientStreamTracer.Factory() {}; ClientStreamTracer.Factory factory2 = new ClientStreamTracer.Factory() {}; CallOptions baseOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory1); CallOptions defaultOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory2); DefaultCallOptionsClientInterceptor interceptor = new DefaultCallOptionsClientInterceptor(defaultOptions); CallOptions patchedOptions = interceptor.patchOptions(baseOptions); assertThat(patchedOptions.getStreamTracerFactories()).containsExactly(factory1, factory2); }
@Test public void customKeyTransfers() { CallOptions.Key<String> k1 = CallOptions.Key.of("k1", null); CallOptions.Key<String> k2 = CallOptions.Key.of("k2", null); CallOptions baseOptions = CallOptions.DEFAULT.withOption(k1, "FOO"); CallOptions defaultOptions = CallOptions.DEFAULT.withOption(k2, "BAR"); DefaultCallOptionsClientInterceptor interceptor = new DefaultCallOptionsClientInterceptor(defaultOptions); CallOptions patchedOptions = interceptor.patchOptions(baseOptions); assertThat(patchedOptions.getOption(k1)).isEqualTo("FOO"); assertThat(patchedOptions.getOption(k2)).isEqualTo("BAR"); }
@Test public void noOverwriteWorks() { CallOptions baseOptions = CallOptions.DEFAULT.withAuthority("FOO"); CallOptions defaultOptions = CallOptions.DEFAULT.withAuthority("BAR"); DefaultCallOptionsClientInterceptor interceptor = new DefaultCallOptionsClientInterceptor(defaultOptions); CallOptions patchedOptions = interceptor.patchOptions(baseOptions); assertThat(patchedOptions.getAuthority()).isEqualTo("FOO"); }
@Test public void noOverwriteWorksCustomKeys() { CallOptions.Key<String> k1 = CallOptions.Key.of("k1", null); CallOptions.Key<String> k2 = CallOptions.Key.of("k2", null); CallOptions.Key<String> k3 = CallOptions.Key.of("k3", null); CallOptions baseOptions = CallOptions.DEFAULT.withOption(k1, "FOO").withOption(k3, "BAZ"); CallOptions defaultOptions = CallOptions.DEFAULT.withOption(k2, "BAR").withOption(k3, "BOP"); DefaultCallOptionsClientInterceptor interceptor = new DefaultCallOptionsClientInterceptor(defaultOptions); CallOptions patchedOptions = interceptor.patchOptions(baseOptions); assertThat(patchedOptions.getOption(k1)).isEqualTo("FOO"); assertThat(patchedOptions.getOption(k2)).isEqualTo("BAR"); assertThat(patchedOptions.getOption(k3)).isEqualTo("BAZ"); } |
MoreMetadata { public static <T> Metadata.AsciiMarshaller<T> JSON_MARSHALLER(Class<T> clazz) { return new Metadata.AsciiMarshaller<T>() { private TypeToken<T> typeToken = TypeToken.of(clazz); private Gson gson = new Gson(); @Override public String toAsciiString(T value) { try { try (StringWriter sw = new StringWriter()) { gson.toJson(value, typeToken.getType(), new UnicodeEscapingAsciiWriter(sw)); return sw.toString(); } } catch (IOException e) { throw new IllegalArgumentException(e); } } @Override public T parseAsciiString(String serialized) { return gson.fromJson(serialized, typeToken.getType()); } }; } private MoreMetadata(); static Metadata.AsciiMarshaller<T> JSON_MARSHALLER(Class<T> clazz); static Metadata.BinaryMarshaller<T> PROTOBUF_MARSHALLER(Class<T> clazz); static final Metadata.AsciiMarshaller<Boolean> BOOLEAN_MARSHALLER; static final Metadata.AsciiMarshaller<Long> LONG_MARSHALLER; static final Metadata.AsciiMarshaller<Double> DOUBLE_MARSHALLER; } | @Test public void jsonMarshallerRoundtrip() { Foo foo = new Foo(); foo.country = "France"; List<Bar> bars = new ArrayList<>(); Bar bar1 = new Bar(); bar1.cheese = "Brë"; bar1.age = 2; bars.add(bar1); Bar bar2 = new Bar(); bar2.cheese = "Guda<>'"; bar2.age = 4; bars.add(bar2); foo.bars = bars; Metadata.AsciiMarshaller<Foo> marshaller = MoreMetadata.JSON_MARSHALLER(Foo.class); String str = marshaller.toAsciiString(foo); assertThat(str).doesNotContain("ë"); Foo foo2 = marshaller.parseAsciiString(str); assertThat(foo2).isEqualTo(foo); }
@Test public void jsonMarshallerPrimitiveRoundtrip() { Metadata.AsciiMarshaller<Integer> marshaller = MoreMetadata.JSON_MARSHALLER(Integer.class); String s = marshaller.toAsciiString(42); assertThat(s).isEqualTo("42"); Integer l = marshaller.parseAsciiString(s); assertThat(l).isEqualTo(42); }
@Test public void rawJsonToTypedJson() { Metadata.Key<String> stringKey = Metadata.Key.of("key", Metadata.ASCII_STRING_MARSHALLER); Metadata.Key<Bar> barKey = Metadata.Key.of("key", MoreMetadata.JSON_MARSHALLER(Bar.class)); Metadata metadata = new Metadata(); metadata.put(stringKey, "{'cheese': 'swiss', 'age': 42}"); Bar bar = metadata.get(barKey); assertThat(bar).isNotNull(); assertThat(bar.cheese).isEqualTo("swiss"); assertThat(bar.age).isEqualTo(42); } |
MoreMetadata { public static <T extends GeneratedMessageV3> Metadata.BinaryMarshaller<T> PROTOBUF_MARSHALLER(Class<T> clazz) { try { Method defaultInstance = clazz.getMethod("getDefaultInstance"); GeneratedMessageV3 instance = (GeneratedMessageV3) defaultInstance.invoke(null); return new Metadata.BinaryMarshaller<T>() { @Override public byte[] toBytes(T value) { return value.toByteArray(); } @SuppressWarnings("unchecked") @Override public T parseBytes(byte[] serialized) { try { return (T) instance.getParserForType().parseFrom(serialized); } catch (InvalidProtocolBufferException ipbe) { throw new IllegalArgumentException(ipbe); } } }; } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) { throw new IllegalStateException(ex); } } private MoreMetadata(); static Metadata.AsciiMarshaller<T> JSON_MARSHALLER(Class<T> clazz); static Metadata.BinaryMarshaller<T> PROTOBUF_MARSHALLER(Class<T> clazz); static final Metadata.AsciiMarshaller<Boolean> BOOLEAN_MARSHALLER; static final Metadata.AsciiMarshaller<Long> LONG_MARSHALLER; static final Metadata.AsciiMarshaller<Double> DOUBLE_MARSHALLER; } | @Test public void protobufMarshallerRoundtrip() { HelloRequest request = HelloRequest.newBuilder().setName("World").build(); Metadata.BinaryMarshaller<HelloRequest> marshaller = MoreMetadata.PROTOBUF_MARSHALLER(HelloRequest.class); byte[] bytes = marshaller.toBytes(request); HelloRequest request2 = marshaller.parseBytes(bytes); assertThat(request2).isEqualTo(request); }
@Test public void rawBytesToTypedProto() { Metadata.Key<byte[]> byteKey = Metadata.Key.of("key-bin", Metadata.BINARY_BYTE_MARSHALLER); Metadata.Key<HelloRequest> protoKey = Metadata.Key.of("key-bin", MoreMetadata.PROTOBUF_MARSHALLER(HelloRequest.class)); HelloRequest request = HelloRequest.newBuilder().setName("World").build(); Metadata metadata = new Metadata(); metadata.put(byteKey, request.toByteArray()); HelloRequest request2 = metadata.get(protoKey); assertThat(request2).isNotNull(); assertThat(request2.getName()).isEqualTo("World"); } |
AmbientContext { public Object freeze() { checkState(!isFrozen(), "AmbientContext already frozen. Cannot freeze() twice."); freezeKey = new Object(); return freezeKey; } AmbientContext(); AmbientContext(AmbientContext other); static Context initialize(Context context); static AmbientContext current(); static boolean isPresent(); Object freeze(); void thaw(Object freezeKey); Context fork(Context context); boolean isFrozen(); boolean containsKey(Metadata.Key<?> key); void discardAll(Metadata.Key<T> key); @Nullable T get(Metadata.Key<T> key); @Nullable Iterable<T> getAll(final Metadata.Key<T> key); Set<String> keys(); void put(Metadata.Key<T> key, T value); boolean remove(Metadata.Key<T> key, T value); Iterable<T> removeAll(Metadata.Key<T> key); @Override String toString(); } | @Test public void contextDoubleFreezingThrows() { AmbientContext context = new AmbientContext(); context.freeze(); assertThatThrownBy(context::freeze).isInstanceOf(IllegalStateException.class); } |
AmbientContext { public void thaw(Object freezeKey) { checkState(isFrozen(), "AmbientContext is not frozen. Cannot thaw()."); checkArgument(this.freezeKey == freezeKey, "The provided freezeKey is not the same object returned by freeze()"); this.freezeKey = null; } AmbientContext(); AmbientContext(AmbientContext other); static Context initialize(Context context); static AmbientContext current(); static boolean isPresent(); Object freeze(); void thaw(Object freezeKey); Context fork(Context context); boolean isFrozen(); boolean containsKey(Metadata.Key<?> key); void discardAll(Metadata.Key<T> key); @Nullable T get(Metadata.Key<T> key); @Nullable Iterable<T> getAll(final Metadata.Key<T> key); Set<String> keys(); void put(Metadata.Key<T> key, T value); boolean remove(Metadata.Key<T> key, T value); Iterable<T> removeAll(Metadata.Key<T> key); @Override String toString(); } | @Test public void contextThawingNotFrozenThrows() { AmbientContext context = new AmbientContext(); assertThatThrownBy(() -> context.thaw(new Object())).isInstanceOf(IllegalStateException.class); } |
XfccMarshaller implements Metadata.AsciiMarshaller<List<XForwardedClientCert>> { @Override public List<XForwardedClientCert> parseAsciiString(String serialized) { return XfccParser.parse(serialized); } @Override String toAsciiString(List<XForwardedClientCert> value); @Override List<XForwardedClientCert> parseAsciiString(String serialized); } | @Test public void parseSimpleHeaderWorks() { XfccMarshaller marshaller = new XfccMarshaller(); String header = "By=http: "URI=http: List<XForwardedClientCert> certs = marshaller.parseAsciiString(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(0).getHash()).isEqualTo("468ed33be74eee6556d90c0149c1309e9ba61d6425303443c0748a02dd8de688"); assertThat(certs.get(0).getSanUri()).isEqualTo("http: assertThat(certs.get(0).getSubject()).isEmpty(); }
@Test public void parseCompoundHeaderWorks() { XfccMarshaller marshaller = new XfccMarshaller(); String header = "By=http: "By=http: List<XForwardedClientCert> certs = marshaller.parseAsciiString(header); assertThat(certs.size()).isEqualTo(2); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(1).getBy()).isEqualTo("http: }
@Test public void quotedHeaderWorks() { XfccMarshaller marshaller = new XfccMarshaller(); String header = "By=http: "Subject=\"/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client\";URI=http: List<XForwardedClientCert> certs = marshaller.parseAsciiString(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client"); }
@Test public void escapedQuotedHeaderWorks() { XfccMarshaller marshaller = new XfccMarshaller(); String header = "By=http: "Subject=\"/C=US/ST=CA/L=\\\"San Francisco\\\"/OU=Lyft/CN=Test Client\";URI=http: List<XForwardedClientCert> certs = marshaller.parseAsciiString(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=\"San Francisco\"/OU=Lyft/CN=Test Client"); }
@Test public void malformedHeaderThrows() { XfccMarshaller marshaller = new XfccMarshaller(); String header = "KABOOM!"; assertThatThrownBy(() -> marshaller.parseAsciiString(header)).isInstanceOf(RuntimeException.class); } |
XfccParser { static List<XForwardedClientCert> parse(String header) { List<XForwardedClientCert> certs = new ArrayList<>(); for (String element : quoteAwareSplit(header, ',')) { XForwardedClientCert cert = new XForwardedClientCert(); List<String> substrings = quoteAwareSplit(element, ';'); for (String substring : substrings) { List<String> kvp = quoteAwareSplit(substring, '='); String key = kvp.get(0).toLowerCase(); String value = kvp.get(1); if (key.equalsIgnoreCase(XFCC_BY)) { cert.setBy(dequote(value)); } if (key.equalsIgnoreCase(XFCC_HASH)) { cert.setHash(dequote(value)); } if (key.equalsIgnoreCase(XFCC_SAN) || key.equalsIgnoreCase(XFCC_URI)) { cert.setSanUri(dequote(value)); } if (key.equalsIgnoreCase(XFCC_DNS)) { cert.addSanDns(dequote(value)); } if (key.equalsIgnoreCase(XFCC_SUBJECT)) { cert.setSubject(dequote(value)); } } certs.add(cert); } return certs; } private XfccParser(); } | @Test public void parseLegacySanHeaderWorks() { String header = "By=http: "SAN=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(0).getHash()).isEqualTo("468ed33be74eee6556d90c0149c1309e9ba61d6425303443c0748a02dd8de688"); assertThat(certs.get(0).getSanUri()).isEqualTo("http: assertThat(certs.get(0).getSubject()).isEmpty(); assertThat(certs.get(0).getSanDns()).isEmpty(); }
@Test public void parseSimpleHeaderWorks() { String header = "Hash=ebb216c5155a5fd8c8f082a07362b3c7b1a8ee2f98c20f6142b49fe5c2db90bd;DNS=test-tls-in;DNS=second-san;" + "DNS=third-san;Subject=\"OU=0:test-tls-in,CN=localhost\""; List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getBy()).isEmpty(); assertThat(certs.get(0).getHash()).isEqualTo("ebb216c5155a5fd8c8f082a07362b3c7b1a8ee2f98c20f6142b49fe5c2db90bd"); assertThat(certs.get(0).getSanUri()).isEmpty(); assertThat(certs.get(0).getSubject()).isEqualTo("OU=0:test-tls-in,CN=localhost"); assertThat(certs.get(0).getSanDns()).containsExactly("test-tls-in", "second-san", "third-san"); }
@Test public void parseUriSanHeaderWorks() { String header = "By=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(0).getHash()).isEqualTo("468ed33be74eee6556d90c0149c1309e9ba61d6425303443c0748a02dd8de688"); assertThat(certs.get(0).getSanUri()).isEqualTo("http: assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client"); assertThat(certs.get(0).getSanDns()).isEmpty(); }
@Test public void parseUriAndDnsSanHeaderWorks() { String header = "By=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(0).getHash()).isEqualTo("468ed33be74eee6556d90c0149c1309e9ba61d6425303443c0748a02dd8de688"); assertThat(certs.get(0).getSanUri()).isEqualTo("http: assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client"); assertThat(certs.get(0).getSanDns()).containsExactly("lyft.com", "www.lyft.com"); }
@Test public void parseCompoundHeaderWorks() { String header = "By=http: "By=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(2); assertThat(certs.get(0).getBy()).isEqualTo("http: assertThat(certs.get(1).getBy()).isEqualTo("http: }
@Test public void quotedHeaderWorks() { String header = "By=http: "Subject=\"/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client\";SAN=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=San Francisco/OU=Lyft/CN=Test Client"); }
@Test public void escapedQuotedHeaderWorks() { String header = "By=http: "Subject=\"/C=US/ST=CA/L=\\\"San Francisco\\\"/OU=Lyft/CN=Test Client\";SAN=http: List<XForwardedClientCert> certs = XfccParser.parse(header); assertThat(certs.size()).isEqualTo(1); assertThat(certs.get(0).getSubject()).isEqualTo("/C=US/ST=CA/L=\"San Francisco\"/OU=Lyft/CN=Test Client"); }
@Test public void mismatchedQuotesThrows() { String header = "By=http: "Subject=\"/C=US/ST=CA/L=\\\"San Francisco\"/OU=Lyft/CN=Test Client\";SAN=http: assertThatThrownBy(() -> XfccParser.parse(header)).isInstanceOf(RuntimeException.class); }
@Test public void quotedKeyThrows() { String header = "\"By\"=http: "Subject=\"/C=US/ST=CA/L=\\\"San Francisco\"/OU=Lyft/CN=Test Client\";SAN=http: assertThatThrownBy(() -> XfccParser.parse(header)).isInstanceOf(RuntimeException.class); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.