/** * Create a matcher that matches if the examined {@link DisplayData} contains an item with the * specified key and Float value. */ public static Matcher<DisplayData> hasDisplayItem(String key, double value) { return hasDisplayItem(key, DisplayData.Type.FLOAT, value); }
private static Matcher<DisplayData> hasDisplayItem( String key, DisplayData.Type type, Object value) { DisplayData.FormattedItemValue formattedValue = type.format(value); return hasDisplayItem( allOf(hasKey(key), hasType(type), hasValue(formattedValue.getLongValue()))); }
@Test public void testPopulateDisplayData() { DisplayData displayData = DisplayData.from( config.withProjectId(PROJECT_ID).withInstanceId(INSTANCE_ID).withTableId(TABLE_ID) ::populateDisplayData); assertThat( displayData, hasDisplayItem( allOf( hasKey("projectId"), hasLabel("Bigtable Project Id"), hasValue(PROJECT_ID.get())))); assertThat( displayData, hasDisplayItem( allOf( hasKey("instanceId"), hasLabel("Bigtable Instance Id"), hasValue(INSTANCE_ID.get())))); assertThat( displayData, hasDisplayItem( allOf(hasKey("tableId"), hasLabel("Bigtable Table Id"), hasValue(TABLE_ID.get())))); }
/** * Creates a matcher that matches if the examined {@link DisplayData} contains an item with the * specified key. */ public static Matcher<DisplayData> hasDisplayItem(String key) { return hasDisplayItem(hasKey(key)); }
@Test public void testDisplayDataIncludedForDisjointInterfaceHierarchies() { FooOptions fooOptions = PipelineOptionsFactory.as(FooOptions.class); fooOptions.setFoo("foo"); BarOptions barOptions = fooOptions.as(BarOptions.class); barOptions.setBar("bar"); DisplayData data = DisplayData.from(barOptions); assertThat(data, hasDisplayItem(allOf(hasKey("foo"), hasNamespace(FooOptions.class)))); assertThat(data, hasDisplayItem(allOf(hasKey("bar"), hasNamespace(BarOptions.class)))); }
@Test public void testDisplayDataForWrappedFn() { UniqueInts combineFn = new UniqueInts() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", "bar")); } }; Combine.PerKey<?, ?, ?> combine = Combine.perKey(combineFn); DisplayData displayData = DisplayData.from(combine); assertThat(displayData, hasDisplayItem("combineFn", combineFn.getClass())); assertThat(displayData, hasDisplayItem(hasNamespace(combineFn.getClass()))); }
assertThat( data, hasDisplayItem( allOf(hasKey("wrappedKey"), hasNamespace(wrapped.getClass()), hasPath(/* root */ )))); assertThat( data, hasDisplayItem( allOf(hasKey("subCompKey"), hasNamespace(subcomponent.getClass()), hasPath("p"))));
@Test public void testHasValue() { Matcher<DisplayData> matcher = hasDisplayItem(hasValue("bar")); assertFalse(matcher.matches(createDisplayDataWithItem("foo", "baz"))); assertThat(createDisplayDataWithItem("foo", "bar"), matcher); }
@Test public void testAssignDisplayDataUnchanged() { FixedWindows windowFn = FixedWindows.of(Duration.standardHours(5)); Window<Object> original = Window.into(windowFn); WindowingStrategy<?, ?> updated = WindowingStrategy.globalDefault().withWindowFn(windowFn); DisplayData displayData = DisplayData.from(new Window.Assign<>(original, updated)); assertThat(displayData, hasDisplayItem("windowFn", windowFn.getClass())); assertThat(displayData, includesDisplayDataFor("windowFn", windowFn)); assertThat(displayData, not(hasDisplayItem("trigger"))); assertThat(displayData, not(hasDisplayItem("accumulationMode"))); assertThat(displayData, not(hasDisplayItem("allowedLateness"))); assertThat(displayData, not(hasDisplayItem("closingBehavior"))); assertThat(displayData, not(hasDisplayItem("timestampCombiner"))); }
@Test public void testUnspecifiedOptionalProperties() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder.add(DisplayData.item("foo", "bar")); } }); assertThat( data, hasDisplayItem(allOf(hasLabel(nullValue(String.class)), hasUrl(nullValue(String.class))))); }
@Test public void testHasPath() { Matcher<DisplayData> matcher = hasDisplayItem(hasPath("a", "b")); final HasDisplayData subComponent = builder -> builder.include( "b", (HasDisplayData) builder1 -> { builder1.add(DisplayData.item("foo", "bar")); }); assertFalse(matcher.matches(DisplayData.from(subComponent))); assertThat(DisplayData.from(builder -> builder.include("a", subComponent)), matcher); }
@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 testTypeMappings() { DisplayData data = DisplayData.from( new HasDisplayData() { @Override public void populateDisplayData(DisplayData.Builder builder) { builder .add(DisplayData.item("string", "foobar")) .add(DisplayData.item("integer", 123)) .add(DisplayData.item("float", 2.34)) .add(DisplayData.item("boolean", true)) .add(DisplayData.item("java_class", DisplayDataTest.class)) .add(DisplayData.item("timestamp", Instant.now())) .add(DisplayData.item("duration", Duration.standardHours(1))); } }); Collection<Item> items = data.items(); assertThat(items, hasItem(allOf(hasKey("string"), hasType(DisplayData.Type.STRING)))); assertThat(items, hasItem(allOf(hasKey("integer"), hasType(DisplayData.Type.INTEGER)))); assertThat(items, hasItem(allOf(hasKey("float"), hasType(DisplayData.Type.FLOAT)))); assertThat(items, hasItem(allOf(hasKey("boolean"), hasType(DisplayData.Type.BOOLEAN)))); assertThat(items, hasItem(allOf(hasKey("java_class"), hasType(DisplayData.Type.JAVA_CLASS)))); assertThat(items, hasItem(allOf(hasKey("timestamp"), hasType(DisplayData.Type.TIMESTAMP)))); assertThat(items, hasItem(allOf(hasKey("duration"), hasType(DisplayData.Type.DURATION)))); }
@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())))); }
/** * Creates a matcher that matches if the examined {@link DisplayData.Item} contains a key with the * specified value. */ public static Matcher<DisplayData.Item> hasKey(String key) { return hasKey(is(key)); }
/** * Creates a matcher that matches if the examined {@link DisplayData.Item} has the specified * label. */ public static Matcher<DisplayData.Item> hasLabel(String label) { return hasLabel(is(label)); }
/** * Creates a matcher that matches if the examined {@link DisplayData.Item} has the specified * value. */ public static Matcher<DisplayData.Item> hasValue(Object value) { return hasValue(is(value)); }
/** * Creates a matcher that matches if the examined {@link DisplayData.Item} contains the specified * namespace. */ public static Matcher<DisplayData.Item> hasNamespace(Class<?> namespace) { return hasNamespace(Matchers.<Class<?>>is(namespace)); }
@Test public void testDisplayDataExcludedFromOverriddenBaseClass() { ExtendsBaseOptions options = PipelineOptionsFactory.as(ExtendsBaseOptions.class); options.setFoo("bar"); DisplayData displayData = DisplayData.from(options); assertThat(displayData, not(hasDisplayItem(hasNamespace(BaseOptions.class)))); }
@Test @Category(ValidatesRunner.class) public void testPrimitiveReadDisplayData() { DisplayDataEvaluator evaluator = DisplayDataEvaluator.create(); TextIO.Read read = TextIO.read().from("foobar"); Set<DisplayData> displayData = evaluator.displayDataForPrimitiveSourceTransforms(read); assertThat( "TextIO.Read should include the file prefix in its primitive display data", displayData, hasItem(hasDisplayItem(hasValue(startsWith("foobar"))))); }