From 78811b7b27fc12c1561fe6f02a1bb7f32555e833 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Fri, 30 Oct 2020 15:16:40 +0100 Subject: [PATCH 1/7] Metamorph basics test should verify that no unexpected interactions occurred in order. * Added debug output for assertion errors. * Silenced `MockitoHint`s in `LookupTest` (due to showing standard streams). * Added `startEntity`/`endEntity` events where they were previously unverified. * Didn't enable check for unverified interactions yet; `shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource` doesn't pass. * Removed redundant (?) `any()` literal verifications in `shouldMatchCharacterWithQuestionMarkWildcard` and `shouldMatchCharactersInCharacterClass`. --- metamorph/build.gradle | 7 + .../metafacture/metamorph/TestHelpers.java | 56 +++ .../metamorph/TestMetamorphBasics.java | 354 +++++++++--------- .../metamorph/functions/LookupTest.java | 2 +- 4 files changed, 249 insertions(+), 170 deletions(-) create mode 100644 metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java diff --git a/metamorph/build.gradle b/metamorph/build.gradle index a14f783d3..ed537f1a5 100644 --- a/metamorph/build.gradle +++ b/metamorph/build.gradle @@ -39,3 +39,10 @@ sourceSets { output.resourcesDir = sourceSets.test.java.outputDir } } + +test { + testLogging { + showStandardStreams = true + exceptionFormat = 'full' + } +} diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java new file mode 100644 index 000000000..ca1075907 --- /dev/null +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java @@ -0,0 +1,56 @@ +/* + * Copyright 2020 hbz NRW + * + * Licensed under the Apache License, Version 2.0 the "License"; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.metafacture.metamorph; + +import org.metafacture.framework.StreamReceiver; +import org.mockito.InOrder; +import org.mockito.Mockito; +import org.mockito.exceptions.base.MockitoAssertionError; + +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.IntFunction; +import java.util.function.Supplier; + +/** + * Helper functions for Metamorph tests. + * + * @author Jens Wille + */ +public final class TestHelpers { + + public static void assertMorph(final StreamReceiver receiver, final String morphDef, final Consumer in, final Consumer> out) { + assertMorph(receiver, morphDef, in, (s, f) -> out.accept(s)); + } + + public static void assertMorph(final StreamReceiver receiver, final String morphDef, final Consumer in, final BiConsumer, IntFunction> out) { + final Metamorph metamorph = InlineMorph.in(TestHelpers.class).with(morphDef).createConnectedTo(receiver); + final InOrder ordered = Mockito.inOrder(receiver); + + try { + in.accept(metamorph); + out.accept(() -> ordered.verify(receiver), i -> ordered.verify(receiver, Mockito.times(i))); + + ordered.verifyNoMoreInteractions(); + //Mockito.verifyNoMoreInteractions(receiver); + } + catch (final MockitoAssertionError e) { + System.out.println(Mockito.mockingDetails(receiver).printInvocations()); + throw e; + } + } + +} diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java index a564bed85..51e314913 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java @@ -15,15 +15,11 @@ */ package org.metafacture.metamorph; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -41,205 +37,225 @@ public final class TestMetamorphBasics { @Mock private StreamReceiver receiver; - private Metamorph metamorph; - @Test public void shouldUseCustomEntityMarker() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.startEntity("entity"); - metamorph.literal("literal", "Aloha"); - metamorph.endEntity(); - metamorph.endRecord(); - - verify(receiver).literal("data", "Aloha"); + assertMorph(receiver, + "" + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.startEntity("entity"); + i.literal("literal", "Aloha"); + i.endEntity(); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("data", "Aloha"); + o.get().endRecord(); + } + ); } @Test public void shouldHandleUnmatchedLiteralsInElseSource() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("Langeoog", "Moin"); - metamorph.literal("Sylt", "Aloha"); - metamorph.literal("Baltrum", "Moin Moin"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("Langeoog", "Moin"); - ordered.verify(receiver).literal("Hawaii", "Aloha"); - ordered.verify(receiver).literal("Baltrum", "Moin Moin"); - ordered.verify(receiver).endRecord(); + assertMorph(receiver, + "" + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("Langeoog", "Moin"); + i.literal("Sylt", "Aloha"); + i.literal("Baltrum", "Moin Moin"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("Langeoog", "Moin"); + o.get().literal("Hawaii", "Aloha"); + o.get().literal("Baltrum", "Moin Moin"); + o.get().endRecord(); + } + ); } @Test public void shouldHandleUnmatchedLiteralsAndEntitiesInElseSource() { - metamorph = InlineMorph.in(this) // - .with("") // - .with(" ")// - .with("")// - .createConnectedTo(receiver); - testElseData(); + testElseData( + "" + + " " + + "" + ); } @Test public void shouldHandleUnmatchedLiteralsAndEntitiesInElseFlattenedSource() { - metamorph = InlineMorph.in(this) // - .with("") // - .with(" ")// - .with("")// - .createConnectedTo(receiver); - testElseData(); + testElseData( + "" + + " " + + "" + ); } - private void testElseData() { - metamorph.startRecord("1"); - metamorph.literal("Shikotan", "Aekap"); - metamorph.startEntity("Germany"); - metamorph.literal("Langeoog", "Moin"); - metamorph.endEntity(); - metamorph.startEntity("Germany"); - metamorph.literal("Baltrum", "Moin Moin"); - metamorph.endEntity(); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("Shikotan", "Aekap"); - ordered.verify(receiver).literal("Germany.Langeoog", "Moin"); - ordered.verify(receiver).literal("Germany.Baltrum", "Moin Moin"); - ordered.verify(receiver).endRecord(); + + private void testElseData(final String morphDef) { + assertMorph(receiver, morphDef, + i -> { + i.startRecord("1"); + i.literal("Shikotan", "Aekap"); + i.startEntity("Germany"); + i.literal("Langeoog", "Moin"); + i.endEntity(); + i.startEntity("Germany"); + i.literal("Baltrum", "Moin Moin"); + i.endEntity(); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("Shikotan", "Aekap"); + o.get().literal("Germany.Langeoog", "Moin"); + o.get().literal("Germany.Baltrum", "Moin Moin"); + o.get().endRecord(); + } + ); } @Test public void shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource() { - metamorph = InlineMorph.in(this).with("")// - .with(" ")// - .with(" ") - .with(" ")// - .with(" ")// - .with("")// - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("Shikotan", "Aekap"); - metamorph.startEntity("Germany"); - metamorph.literal("Langeoog", "Moin"); - metamorph.literal("Baltrum", "Moin Moin"); - metamorph.endEntity(); - metamorph.startEntity("USA"); - metamorph.literal("Sylt", "Aloha"); - metamorph.endEntity(); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("Shikotan", "Aekap"); - ordered.verify(receiver).startEntity("Germany"); - ordered.verify(receiver).literal("Langeoog", "Moin"); - ordered.verify(receiver).literal("Baltrum", "Moin Moin"); - ordered.verify(receiver).endEntity(); - ordered.verify(receiver).startEntity("USA"); - ordered.verify(receiver).literal("Hawaii", "Aloha"); - ordered.verify(receiver).endEntity(); - ordered.verify(receiver).endRecord(); + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("Shikotan", "Aekap"); + i.startEntity("Germany"); + i.literal("Langeoog", "Moin"); + i.literal("Baltrum", "Moin Moin"); + i.endEntity(); + i.startEntity("USA"); + i.literal("Sylt", "Aloha"); + i.endEntity(); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("Shikotan", "Aekap"); + o.get().startEntity("Germany"); + o.get().literal("Langeoog", "Moin"); + //o.get().endEntity(); + //o.get().startEntity("Germany"); + o.get().literal("Baltrum", "Moin Moin"); + o.get().endEntity(); + o.get().startEntity("USA"); + o.get().literal("Hawaii", "Aloha"); + o.get().endEntity(); + o.get().endRecord(); + } + ); } @Test public void shouldMatchCharacterWithQuestionMarkWildcard() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("lit", "Moin"); - metamorph.literal("lit-A", "Aloha"); - metamorph.literal("lit-B", "Aloha 'oe"); - metamorph.endRecord(); - - verify(receiver).literal("lit-A", "Aloha"); - verify(receiver).literal("lit-B", "Aloha 'oe"); - verify(receiver, times(2)).literal(any(), any()); + assertMorph(receiver, + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("lit", "Moin"); + i.literal("lit-A", "Aloha"); + i.literal("lit-B", "Aloha 'oe"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("lit-A", "Aloha"); + o.get().literal("lit-B", "Aloha 'oe"); + o.get().endRecord(); + } + ); } @Test public void shouldMatchCharactersInCharacterClass() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("lit-A", "Hawaii"); - metamorph.literal("lit-B", "Oahu"); - metamorph.literal("lit-C", "Fehmarn"); - metamorph.endRecord(); - - verify(receiver).literal("lit-A", "Hawaii"); - verify(receiver).literal("lit-B", "Oahu"); - verify(receiver, times(2)).literal(any(), any()); + assertMorph(receiver, + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("lit-A", "Hawaii"); + i.literal("lit-B", "Oahu"); + i.literal("lit-C", "Fehmarn"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("lit-A", "Hawaii"); + o.get().literal("lit-B", "Oahu"); + o.get().endRecord(); + } + ); } @Test public void shouldReplaceVariables() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("Honolulu", "Aloha"); - metamorph.endRecord(); - - verify(receiver).literal("Hawaii", "Aloha"); + assertMorph(receiver, + "" + + " " + + " " + + "" + + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("Honolulu", "Aloha"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("Hawaii", "Aloha"); + o.get().endRecord(); + } + ); } @Test public void shouldAllowTreatingEntityEndEventsAsLiterals() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("entity end info"); - metamorph.startEntity("e1"); - metamorph.startEntity("e2"); - metamorph.literal("d", "a"); - metamorph.endEntity(); - metamorph.endEntity(); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("entity end info"); - ordered.verify(receiver).literal("e1.e2.d", "a"); - ordered.verify(receiver).literal("e1.e2", ""); - ordered.verify(receiver).literal("e1", ""); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); + assertMorph(receiver, + "" + + " " + + " " + + " " + + "", + i -> { + i.startRecord("entity end info"); + i.startEntity("e1"); + i.startEntity("e2"); + i.literal("d", "a"); + i.endEntity(); + i.endEntity(); + i.endRecord(); + }, + o -> { + o.get().startRecord("entity end info"); + o.get().literal("e1.e2.d", "a"); + o.get().literal("e1.e2", ""); + o.get().literal("e1", ""); + o.get().endRecord(); + } + ); } } diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java index ecf630d5f..aaccb64c9 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java @@ -49,7 +49,7 @@ public final class LookupTest { private static final String VALUE = "Kafka"; @Rule - public MockitoRule mockito = MockitoJUnit.rule(); + public MockitoRule mockito = MockitoJUnit.rule().silent(); @Mock private Maps maps; From e4c6fe512476ed893a578c65b33cd490ec45ba37 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Fri, 30 Oct 2020 15:26:37 +0100 Subject: [PATCH 2/7] Metamorph basics test should verify that no unexpected interactions occurred at all. * Changed `shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource` to match actual behaviour (see #338). --- .../src/test/java/org/metafacture/metamorph/TestHelpers.java | 2 +- .../java/org/metafacture/metamorph/TestMetamorphBasics.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java index ca1075907..5617f8b0b 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java @@ -45,7 +45,7 @@ public static void assertMorph(final StreamReceiver receiver, final String morph out.accept(() -> ordered.verify(receiver), i -> ordered.verify(receiver, Mockito.times(i))); ordered.verifyNoMoreInteractions(); - //Mockito.verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } catch (final MockitoAssertionError e) { System.out.println(Mockito.mockingDetails(receiver).printInvocations()); diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java index 51e314913..e2ee92dac 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java @@ -152,8 +152,8 @@ public void shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource() { o.get().literal("Shikotan", "Aekap"); o.get().startEntity("Germany"); o.get().literal("Langeoog", "Moin"); - //o.get().endEntity(); - //o.get().startEntity("Germany"); + o.get().endEntity(); + o.get().startEntity("Germany"); o.get().literal("Baltrum", "Moin Moin"); o.get().endEntity(); o.get().startEntity("USA"); From 344ce03cea8ee3457ace5d7afc316d638b943152 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Mon, 2 Nov 2020 15:23:26 +0100 Subject: [PATCH 3/7] Metamorph macros test should verify that no unexpected interactions occurred. * Added `startRecord`/`endRecord` events where they were previously unverified. --- .../metamorph/TestMetamorphMacros.java | 250 +++++++++--------- 1 file changed, 119 insertions(+), 131 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java index c256a3f6f..f0edadee3 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java @@ -15,13 +15,11 @@ */ package org.metafacture.metamorph; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,162 +37,152 @@ public class TestMetamorphMacros { @Mock private StreamReceiver receiver; - private Metamorph metamorph; - @Test public void shouldReplaceCallMacroWithMacro() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("in1", "Hawaii"); - metamorph.literal("in2", "Maui"); - metamorph.endRecord(); - - verify(receiver).literal("out1", "Hawaii"); - verify(receiver).literal("out2", "Maui"); + assertMorph(receiver, + "" + + " " + + " " + + " " + + "" + + "" + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("in1", "Hawaii"); + i.literal("in2", "Maui"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("out1", "Hawaii"); + o.get().literal("out2", "Maui"); + o.get().endRecord(); + } + ); } @Test public void shouldAllowCallMacroInEntities() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verifyEntityWithSingleLiteral(); + testSingleLiteral(true, + "" + + " " + + " " + + " " + + "" + + "" + + " " + + " " + + " " + + "" + ); } @Test public void shouldAllowNestedMacros() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verifyEntityWithSingleLiteral(); + testSingleLiteral(true, + "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + "" + + "" + + " " + + "" + ); } @Test public void shouldAllowoForwardReferencingMacros() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verifyEntityWithSingleLiteral(); + testSingleLiteral(true, + "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + "" + + "" + + " " + + "" + ); } @Test public void shouldSupportVariablesInMacroParameters() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verifyEntityWithSingleLiteral(); + testSingleLiteral(true, + "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + "" + + "" + + " " + + "" + ); } @Test public void issue227_shouldSupportXincludeForMacros() { - metamorph = InlineMorph.in(this) - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verify(receiver).literal("Honolulu", "Aloha"); + testSingleLiteral(false, + "" + + "" + + " " + + "" + ); } @Test public void shouldSupportXPointer() { - metamorph = InlineMorph.in(this) - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - processRecordWithSingleLiteral(); - - verify(receiver).literal("Honolulu", "Aloha"); - } - - private void processRecordWithSingleLiteral() { - metamorph.startRecord("1"); - metamorph.literal("Honolulu", "Aloha"); - metamorph.endRecord(); + testSingleLiteral(false, + "" + + "" + + " " + + "" + ); } - private void verifyEntityWithSingleLiteral() { - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startEntity("Hawaii"); - ordered.verify(receiver).literal("Honolulu", "Aloha"); - ordered.verify(receiver).endEntity(); + private void testSingleLiteral(final boolean withEntity, final String morphDef) { + assertMorph(receiver, morphDef, + i -> { + i.startRecord("1"); + i.literal("Honolulu", "Aloha"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + + if (withEntity) { + o.get().startEntity("Hawaii"); + } + + o.get().literal("Honolulu", "Aloha"); + + if (withEntity) { + o.get().endEntity(); + } + + o.get().endRecord(); + } + ); } } From a0f49a88bce5f3319dba419396c8fe3b1045a2e3 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Mon, 2 Nov 2020 15:25:34 +0100 Subject: [PATCH 4/7] Metamorph file map test should verify that no unexpected interactions occurred. --- .../metamorph/maps/FileMapTest.java | 111 +++++++++--------- 1 file changed, 53 insertions(+), 58 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java b/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java index bde21a7f1..17b544d4f 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java @@ -15,14 +15,11 @@ */ package org.metafacture.metamorph.maps; -import static org.mockito.Mockito.inOrder; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.InlineMorph; -import org.metafacture.metamorph.Metamorph; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -35,65 +32,63 @@ */ public final class FileMapTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); + @Rule + public final MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock - private StreamReceiver receiver; + @Mock + private StreamReceiver receiver; - private Metamorph metamorph; - - @Test - public void shouldLookupValuesInFileBasedMap() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "gw"); - metamorph.literal("1", "fj"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("1", "Germany"); - ordered.verify(receiver).literal("1", "Fiji"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); - } + @Test + public void shouldLookupValuesInFileBasedMap() { + assertMorph(receiver, + "" + + " " + + " " + + " " + + "" + + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "gw"); + i.literal("1", "fj"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("1", "Germany"); + o.get().literal("1", "Fiji"); + o.get().endRecord(); + } + ); + } @Test public void shouldWhitelistValuesInFileBasedMap() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "gw"); - metamorph.literal("1", "fj"); - metamorph.literal("1", "bla"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("1", "gw"); - ordered.verify(receiver).literal("1", "fj"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); + assertMorph(receiver, + "" + + " " + + " " + + " " + + "" + + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "gw"); + i.literal("1", "fj"); + i.literal("1", "bla"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("1", "gw"); + o.get().literal("1", "fj"); + o.get().endRecord(); + } + ); } } From 1ffb73dde9d3f67899482729e3c40bfe01c47c38 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Mon, 2 Nov 2020 15:25:57 +0100 Subject: [PATCH 5/7] Metamorph Java map test should verify that no unexpected interactions occurred. --- .../metamorph/maps/JavaMapTest.java | 65 +++++++++---------- 1 file changed, 30 insertions(+), 35 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java b/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java index fbd4c6039..59ef90b5a 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java @@ -15,14 +15,11 @@ */ package org.metafacture.metamorph.maps; -import static org.mockito.Mockito.inOrder; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.InlineMorph; -import org.metafacture.metamorph.Metamorph; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -36,38 +33,36 @@ */ public final class JavaMapTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); + @Rule + public final MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock - private StreamReceiver receiver; + @Mock + private StreamReceiver receiver; - private Metamorph metamorph; - - @Test - public void shouldLookupValuesInJavaBackedMap() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with("") - .with("") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "gw"); - metamorph.literal("1", "fj"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("1", "Germany"); - ordered.verify(receiver).literal("1", "Fiji"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); - } + @Test + public void shouldLookupValuesInJavaBackedMap() { + assertMorph(receiver, + "" + + " " + + " " + + " " + + "" + + "" + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "gw"); + i.literal("1", "fj"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("1", "Germany"); + o.get().literal("1", "Fiji"); + o.get().endRecord(); + } + ); + } } From 3fc965b5c164e44b4e3e800c873942f162b5d998 Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Mon, 2 Nov 2020 15:27:22 +0100 Subject: [PATCH 6/7] Metamorph unique function test should verify that no unexpected interactions occurred. --- .../metamorph/functions/UniqueTest.java | 208 +++++++++--------- 1 file changed, 101 insertions(+), 107 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java index 658b57554..2fcdf7c96 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java @@ -15,15 +15,11 @@ */ package org.metafacture.metamorph.functions; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.InlineMorph; -import org.metafacture.metamorph.Metamorph; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -42,114 +38,112 @@ public final class UniqueTest { @Mock private StreamReceiver receiver; - private Metamorph metamorph; - @Test public void shouldAllowSelectingTheUniqueScope() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.startEntity("e"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endEntity(); - metamorph.startEntity("e"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endEntity(); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endRecord(); - metamorph.startRecord("2"); - metamorph.startEntity("e"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endEntity(); - metamorph.startEntity("e"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endEntity(); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.literal("data", "d"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver, times(2)).literal("inEntity", "d"); - ordered.verify(receiver).literal("inRecord", "d"); - ordered.verify(receiver).endRecord(); - ordered.verify(receiver).startRecord("2"); - ordered.verify(receiver, times(2)).literal("inEntity", "d"); - ordered.verify(receiver).literal("inRecord", "d"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.startEntity("e"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endEntity(); + i.startEntity("e"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endEntity(); + i.literal("data", "d"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endRecord(); + i.startRecord("2"); + i.startEntity("e"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endEntity(); + i.startEntity("e"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endEntity(); + i.literal("data", "d"); + i.literal("data", "d"); + i.literal("data", "d"); + i.endRecord(); + }, + (o, f) -> { + o.get().startRecord("1"); + f.apply(2).literal("inEntity", "d"); + o.get().literal("inRecord", "d"); + o.get().endRecord(); + o.get().startRecord("2"); + f.apply(2).literal("inEntity", "d"); + o.get().literal("inRecord", "d"); + o.get().endRecord(); + } + ); } @Test public void shouldAllowSelectingTheUniquePart() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("data1", "d1"); - metamorph.literal("data1", "d1"); - metamorph.literal("data1", "d2"); - metamorph.literal("data1", "d2"); - metamorph.literal("data2", "d2"); - metamorph.literal("data2", "d2"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("name", "d1"); - ordered.verify(receiver).literal("value", "d1"); - ordered.verify(receiver).literal("both", "d1"); - ordered.verify(receiver).literal("value", "d2"); - ordered.verify(receiver).literal("both", "d2"); - ordered.verify(receiver).literal("name", "d2"); - ordered.verify(receiver).literal("both", "d2"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("data1", "d1"); + i.literal("data1", "d1"); + i.literal("data1", "d2"); + i.literal("data1", "d2"); + i.literal("data2", "d2"); + i.literal("data2", "d2"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("name", "d1"); + o.get().literal("value", "d1"); + o.get().literal("both", "d1"); + o.get().literal("value", "d2"); + o.get().literal("both", "d2"); + o.get().literal("name", "d2"); + o.get().literal("both", "d2"); + o.get().endRecord(); + } + ); } } From 4b764919428c273277166d246e7688125af23aec Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Mon, 2 Nov 2020 15:37:35 +0100 Subject: [PATCH 7/7] Metamorph tuples collector test should verify that no unexpected interactions occurred. --- .../metamorph/collectors/TuplesTest.java | 247 +++++++++--------- 1 file changed, 121 insertions(+), 126 deletions(-) diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java index 5fdd1a363..1909c9b09 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java @@ -15,14 +15,11 @@ */ package org.metafacture.metamorph.collectors; -import static org.mockito.Mockito.inOrder; +import static org.metafacture.metamorph.TestHelpers.assertMorph; import org.junit.Rule; import org.junit.Test; import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.InlineMorph; -import org.metafacture.metamorph.Metamorph; -import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -35,127 +32,125 @@ */ public final class TuplesTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); - - @Mock - private StreamReceiver receiver; - - private Metamorph metamorph; - - @Test - public void shouldEmitTwoandThreeTuples() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "a"); - metamorph.literal("1", "b"); - metamorph.literal("2", "A"); - metamorph.literal("2", "B"); - metamorph.endRecord(); - metamorph.startRecord("2"); - metamorph.literal("3", "X"); - metamorph.literal("1", "c"); - metamorph.literal("1", "d"); - metamorph.literal("2", "C"); - metamorph.literal("3", "Y"); - metamorph.literal("2", "D"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("product", "aA"); - ordered.verify(receiver).literal("product", "bA"); - ordered.verify(receiver).literal("product", "aB"); - ordered.verify(receiver).literal("product", "bB"); - ordered.verify(receiver).endRecord(); - ordered.verify(receiver).startRecord("2"); - ordered.verify(receiver).literal("product", "cCX"); - ordered.verify(receiver).literal("product", "dCX"); - ordered.verify(receiver).literal("product", "cDX"); - ordered.verify(receiver).literal("product", "dDX"); - ordered.verify(receiver).literal("product", "cCY"); - ordered.verify(receiver).literal("product", "dCY"); - ordered.verify(receiver).literal("product", "cDY"); - ordered.verify(receiver).literal("product", "dDY"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); - } - - @Test - public void shouldOnlyEmitTriplesWithMoreThanMinNValues() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "a"); - metamorph.literal("1", "b"); - metamorph.literal("2", "A"); - metamorph.literal("2", "B"); - metamorph.endRecord(); - metamorph.startRecord("2"); - metamorph.literal("3", "X"); - metamorph.literal("1", "c"); - metamorph.literal("1", "d"); - metamorph.literal("2", "C"); - metamorph.literal("3", "Y"); - metamorph.literal("2", "D"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).endRecord(); - ordered.verify(receiver).startRecord("2"); - ordered.verify(receiver).literal("product", "cCX"); - ordered.verify(receiver).literal("product", "dCX"); - ordered.verify(receiver).literal("product", "cDX"); - ordered.verify(receiver).literal("product", "dDX"); - ordered.verify(receiver).literal("product", "cCY"); - ordered.verify(receiver).literal("product", "dCY"); - ordered.verify(receiver).literal("product", "cDY"); - ordered.verify(receiver).literal("product", "dDY"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); - } - - @Test - public void shouldEmitTuplesWithMinNIfNotAllStatementsFired() { - metamorph = InlineMorph.in(this) - .with("") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with(" ") - .with("") - .createConnectedTo(receiver); - - metamorph.startRecord("1"); - metamorph.literal("1", "a"); - metamorph.literal("1", "b"); - metamorph.endRecord(); - - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord("1"); - ordered.verify(receiver).literal("product", "a"); - ordered.verify(receiver).literal("product", "b"); - ordered.verify(receiver).endRecord(); - ordered.verifyNoMoreInteractions(); - } + @Rule + public final MockitoRule mockitoRule = MockitoJUnit.rule(); + + @Mock + private StreamReceiver receiver; + + @Test + public void shouldEmitTwoAndThreeTuples() { + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "a"); + i.literal("1", "b"); + i.literal("2", "A"); + i.literal("2", "B"); + i.endRecord(); + i.startRecord("2"); + i.literal("3", "X"); + i.literal("1", "c"); + i.literal("1", "d"); + i.literal("2", "C"); + i.literal("3", "Y"); + i.literal("2", "D"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("product", "aA"); + o.get().literal("product", "bA"); + o.get().literal("product", "aB"); + o.get().literal("product", "bB"); + o.get().endRecord(); + o.get().startRecord("2"); + o.get().literal("product", "cCX"); + o.get().literal("product", "dCX"); + o.get().literal("product", "cDX"); + o.get().literal("product", "dDX"); + o.get().literal("product", "cCY"); + o.get().literal("product", "dCY"); + o.get().literal("product", "cDY"); + o.get().literal("product", "dDY"); + o.get().endRecord(); + } + ); + } + + @Test + public void shouldOnlyEmitTriplesWithMoreThanMinNValues() { + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "a"); + i.literal("1", "b"); + i.literal("2", "A"); + i.literal("2", "B"); + i.endRecord(); + i.startRecord("2"); + i.literal("3", "X"); + i.literal("1", "c"); + i.literal("1", "d"); + i.literal("2", "C"); + i.literal("3", "Y"); + i.literal("2", "D"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().endRecord(); + o.get().startRecord("2"); + o.get().literal("product", "cCX"); + o.get().literal("product", "dCX"); + o.get().literal("product", "cDX"); + o.get().literal("product", "dDX"); + o.get().literal("product", "cCY"); + o.get().literal("product", "dCY"); + o.get().literal("product", "cDY"); + o.get().literal("product", "dDY"); + o.get().endRecord(); + } + ); + } + + @Test + public void shouldEmitTuplesWithMinNIfNotAllStatementsFired() { + assertMorph(receiver, + "" + + " " + + " " + + " " + + " " + + " " + + "", + i -> { + i.startRecord("1"); + i.literal("1", "a"); + i.literal("1", "b"); + i.endRecord(); + }, + o -> { + o.get().startRecord("1"); + o.get().literal("product", "a"); + o.get().literal("product", "b"); + o.get().endRecord(); + } + ); + } }