@Override protected Collection<Item> featureValueOf(DisplayData actual) { return actual.items(); } };
@Override protected boolean matchesSafely(DisplayData data, Description mismatchDescription) { Collection<Item> items = data.items(); boolean isMatch = Matchers.hasItem(itemMatcher).matches(items); if (!isMatch) { mismatchDescription.appendText("found " + items.size() + " non-matching item(s):\n"); mismatchDescription.appendValue(data); } return isMatch; } }
@Override protected boolean matchesSafely(DisplayData displayData) { DisplayData subComponentData = subComponentData(path); if (subComponentData.items().isEmpty()) { throw new UnsupportedOperationException( "subComponent contains no display data; " + "cannot verify whether it is included"); } DisplayDataComparison comparison = checkSubset(displayData, subComponentData, path); return comparison.missingItems.isEmpty(); }
@Test public void testPopulateDisplayDataDefaultBehavior() { PTransform<PCollection<String>, PCollection<String>> transform = new PTransform<PCollection<String>, PCollection<String>>() { @Override public PCollection<String> expand(PCollection<String> begin) { throw new IllegalArgumentException("Should never be applied"); } }; DisplayData displayData = DisplayData.from(transform); assertThat(displayData.items(), empty()); }
@Test public void testLambdaDisplayData() { Combine.Globally<?, ?> combine = Combine.globally(xs -> Iterables.getFirst(xs, 0)); DisplayData displayData = DisplayData.from(combine); MatcherAssert.assertThat(displayData.items(), not(empty())); } }
@Test public void testDefaultPopulateDisplayDataImplementation() { DoFn<String, String> fn = new DoFn<String, String>() {}; DisplayData displayData = DisplayData.from(fn); assertThat(displayData.items(), empty()); } }
@Test public void testDefaultInstance() { DisplayData none = DisplayData.none(); assertThat(none.items(), empty()); }
@Test public void testIncludesSubcomponentsWithObjectEquality() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder .include("p1", new EqualsEverything("foo1", "bar1")) .include("p2", new EqualsEverything("foo2", "bar2")); } }); assertThat(data.items(), hasSize(2)); }
@Test public void testDuplicateKeyWithNamespaceOverrideDoesntThrow() { DisplayData displayData = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder .add(DisplayData.item("foo", "bar")) .add(DisplayData.item("foo", "baz").withNamespace(DisplayDataTest.class)); } }); assertThat(displayData.items(), hasSize(2)); }
@Test public void testContextProperlyReset() { final HasDisplayData subComponent = new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", "bar")); } }; HasDisplayData component = new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.include("p", subComponent).add(DisplayData.item("alpha", "bravo")); } }; DisplayData data = DisplayData.from(component); assertThat(data.items(), hasItem(allOf(hasKey("alpha"), hasNamespace(component.getClass())))); }
@Test public void testStaticValueProviderString() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", StaticValueProvider.of("bar"))); } }); assertThat(data.items(), hasSize(1)); assertThat(data, hasDisplayItem("foo", "bar")); }
@Test public void testCanBuildDisplayData() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", "bar")); } }); assertThat(data.items(), hasSize(1)); assertThat(data, hasDisplayItem("foo", "bar")); }
@Test public void testStaticValueProviderInt() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", StaticValueProvider.of(1))); } }); assertThat(data.items(), hasSize(1)); assertThat(data, hasDisplayItem("foo", 1)); }
private DisplayDataComparison checkSubset( DisplayData displayData, DisplayData included, String path) { DisplayDataComparison comparison = new DisplayDataComparison(displayData.items()); for (Item item : included.items()) { Item matchedItem = displayData .asMap() .get( DisplayData.Identifier.of( DisplayData.Path.absolute(path), item.getNamespace(), item.getKey())); if (matchedItem != null) { comparison.matched(matchedItem); } else { comparison.missing(item); } } return comparison; }
@Test public void testStaticValueProviderDate() { final Instant value = Instant.now(); DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", StaticValueProvider.of(value))); } }); @SuppressWarnings("unchecked") DisplayData.Item item = (DisplayData.Item) data.items().toArray()[0]; @SuppressWarnings("unchecked") Matcher<Item> matchesAllOf = allOf( hasKey("foo"), hasType(DisplayData.Type.TIMESTAMP), hasValue(ISO_FORMATTER.print(value))); assertThat(item, matchesAllOf); }
@Test public void testAsMap() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", "bar")); } }); Map<DisplayData.Identifier, DisplayData.Item> map = data.asMap(); assertEquals(1, map.size()); assertThat(data, hasDisplayItem("foo", "bar")); assertEquals(map.values(), data.items()); }
@Test public void testParseDisplayData() { TikaIO.Parse parse = TikaIO.parse().filepattern("file.pdf"); DisplayData displayData = DisplayData.from(parse); assertThat(displayData, hasDisplayItem("filePattern", "file.pdf")); assertEquals(1, displayData.items().size()); }
@Test public void testDisplayData() { GroupByKey<String, String> groupByKey = GroupByKey.create(); GroupByKey<String, String> groupByFewKeys = GroupByKey.createWithFewKeys(); DisplayData gbkDisplayData = DisplayData.from(groupByKey); DisplayData fewKeysDisplayData = DisplayData.from(groupByFewKeys); assertThat(gbkDisplayData.items(), empty()); assertThat(fewKeysDisplayData, hasDisplayItem("fewKeys", true)); }
@Test public void testHandlesIncludeCyclesDifferentInstances() { HasDisplayData component = new DelegatingDisplayData(new DelegatingDisplayData(new NoopDisplayData())); DisplayData data = DisplayData.from(component); assertThat(data.items(), hasSize(2)); }
@Test public void displayData() throws Exception { SpannerIO.Write write = SpannerIO.write() .withProjectId("test-project") .withInstanceId("test-instance") .withDatabaseId("test-database") .withBatchSizeBytes(123); DisplayData data = DisplayData.from(write); assertThat(data.items(), hasSize(4)); assertThat(data, hasDisplayItem("projectId", "test-project")); assertThat(data, hasDisplayItem("instanceId", "test-instance")); assertThat(data, hasDisplayItem("databaseId", "test-database")); assertThat(data, hasDisplayItem("batchSizeBytes", 123)); }