From 13fa6064778bd0204334ce2c4958e1c9efd75dcc Mon Sep 17 00:00:00 2001 From: yaroslav-orel Date: Fri, 5 Jan 2018 14:53:22 +0200 Subject: [PATCH 1/5] Fix logic when factory is provided as constructor --- .../automation/testng/ListenerChain.java | 46 ++++--------------- 1 file changed, 10 insertions(+), 36 deletions(-) diff --git a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java index 0b63e4a..5d79817 100644 --- a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java +++ b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java @@ -1,43 +1,14 @@ package com.nordstrom.automation.testng; +import com.google.common.collect.Lists; +import org.testng.*; +import org.testng.annotations.*; +import org.testng.internal.InvokedMethod; + import java.lang.reflect.Constructor; import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Objects; +import java.util.*; import java.util.Optional; -import java.util.ServiceLoader; -import java.util.Set; - -import org.testng.IAnnotationTransformer; -import org.testng.IAnnotationTransformer2; -import org.testng.IAnnotationTransformer3; -import org.testng.IClassListener; -import org.testng.IConfigurationListener; -import org.testng.IConfigurationListener2; -import org.testng.IInvokedMethod; -import org.testng.IInvokedMethodListener; -import org.testng.IInvokedMethodListener2; -import org.testng.IMethodInstance; -import org.testng.IMethodInterceptor; -import org.testng.ISuite; -import org.testng.ISuiteListener; -import org.testng.ITestClass; -import org.testng.ITestContext; -import org.testng.ITestListener; -import org.testng.ITestNGListener; -import org.testng.ITestResult; -import org.testng.annotations.IConfigurationAnnotation; -import org.testng.annotations.IDataProviderAnnotation; -import org.testng.annotations.IFactoryAnnotation; -import org.testng.annotations.IListenersAnnotation; -import org.testng.annotations.ITestAnnotation; -import org.testng.internal.InvokedMethod; - -import com.google.common.collect.Lists; /** * This TestNG listener enables the addition of other listeners at runtime and guarantees the order in which they're @@ -171,7 +142,10 @@ public void transform(IDataProviderAnnotation annotation, Method method) { */ @Override public void transform(IFactoryAnnotation annotation, Method method) { - attachListeners(method); + if(method != null) + attachListeners(method); + else + attachListeners(annotation.getDataProviderClass()); synchronized(annotationXformers2) { for (IAnnotationTransformer2 annotationXformer : annotationXformers2) { From 3cf5381438f5b90e28243c7614c964c91ab48656 Mon Sep 17 00:00:00 2001 From: yaroslav-orel Date: Fri, 5 Jan 2018 14:53:54 +0200 Subject: [PATCH 2/5] Add test to verify correct behavior --- .../automation/testng/ConstructorFactory.java | 19 ++++++++++++++ .../automation/testng/ListenerChainTest.java | 26 ++++++++++++++----- 2 files changed, 39 insertions(+), 6 deletions(-) create mode 100644 src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java diff --git a/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java b/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java new file mode 100644 index 0000000..cef56ea --- /dev/null +++ b/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java @@ -0,0 +1,19 @@ +package com.nordstrom.automation.testng; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Factory; +import org.testng.annotations.Test; + +public class ConstructorFactory { + + public ConstructorFactory(){} + + @DataProvider + public Object[] ints(){return new Object[]{1, 2, 3};} + + @Factory(dataProvider = "ints", dataProviderClass = ConstructorFactory.class) + public ConstructorFactory(int i){ } + + @Test + public void test(){} +} diff --git a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java index 866af13..7c21f57 100644 --- a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java +++ b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java @@ -1,16 +1,16 @@ package com.nordstrom.automation.testng; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; +import org.testng.ITestNGListener; +import org.testng.TestListenerAdapter; +import org.testng.TestNG; +import org.testng.annotations.Test; import java.util.Arrays; import java.util.HashSet; import java.util.Set; -import org.testng.ITestNGListener; -import org.testng.TestListenerAdapter; -import org.testng.TestNG; -import org.testng.annotations.Test; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertTrue; public class ListenerChainTest { @@ -331,5 +331,19 @@ public void verifyAfterSkipped() { assertTrue(ChainedListener.testSuccess.contains("testAfterSkipped")); } + + @Test + public void verifyConstructorFactory(){ + ListenerChain lc = new ListenerChain(); + TestListenerAdapter tla = new TestListenerAdapter(); + + TestNG testNG = new TestNG(); + testNG.setTestClasses(new Class[]{ConstructorFactory.class}); + testNG.addListener((ITestNGListener) lc); + testNG.addListener((ITestNGListener) tla); + testNG.run(); + + assertEquals(tla.getPassedTests().size(), 3, "Incorrect passed test count"); + } } From 7db3e4ccb29342049c55a2327db96c16d82f124e Mon Sep 17 00:00:00 2001 From: Scott Babcock Date: Mon, 8 Jan 2018 15:07:49 -0800 Subject: [PATCH 3/5] Revisions inspired by PR for issue #8 --- .../automation/testng/ListenerChain.java | 87 ++++-- .../automation/testng/ChainedListener.java | 64 ++--- .../automation/testng/ConstructorFactory.java | 46 ++-- .../automation/testng/ListenerChainTest.java | 248 +++++++++++------- 4 files changed, 277 insertions(+), 168 deletions(-) diff --git a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java index 5d79817..305d609 100644 --- a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java +++ b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java @@ -1,14 +1,43 @@ package com.nordstrom.automation.testng; -import com.google.common.collect.Lists; -import org.testng.*; -import org.testng.annotations.*; -import org.testng.internal.InvokedMethod; - import java.lang.reflect.Constructor; import java.lang.reflect.Method; -import java.util.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Objects; import java.util.Optional; +import java.util.ServiceLoader; +import java.util.Set; + +import org.testng.IAnnotationTransformer; +import org.testng.IAnnotationTransformer2; +import org.testng.IAnnotationTransformer3; +import org.testng.IClassListener; +import org.testng.IConfigurationListener; +import org.testng.IConfigurationListener2; +import org.testng.IInvokedMethod; +import org.testng.IInvokedMethodListener; +import org.testng.IInvokedMethodListener2; +import org.testng.IMethodInstance; +import org.testng.IMethodInterceptor; +import org.testng.ISuite; +import org.testng.ISuiteListener; +import org.testng.ITestClass; +import org.testng.ITestContext; +import org.testng.ITestListener; +import org.testng.ITestNGListener; +import org.testng.ITestResult; +import org.testng.annotations.IConfigurationAnnotation; +import org.testng.annotations.IDataProviderAnnotation; +import org.testng.annotations.IFactoryAnnotation; +import org.testng.annotations.IListenersAnnotation; +import org.testng.annotations.ITestAnnotation; +import org.testng.internal.InvokedMethod; + +import com.google.common.collect.Lists; /** * This TestNG listener enables the addition of other listeners at runtime and guarantees the order in which they're @@ -142,10 +171,7 @@ public void transform(IDataProviderAnnotation annotation, Method method) { */ @Override public void transform(IFactoryAnnotation annotation, Method method) { - if(method != null) - attachListeners(method); - else - attachListeners(annotation.getDataProviderClass()); + attachListeners(method); synchronized(annotationXformers2) { for (IAnnotationTransformer2 annotationXformer : annotationXformers2) { @@ -570,14 +596,26 @@ public void onAfterClass(ITestClass testClass) { * @param listenerType listener type * @return optional listener instance */ - @SuppressWarnings("unchecked") public static Optional getAttachedListener(ISuite suite, Class listenerType) { Objects.requireNonNull(suite, "[suite] must be non-null"); Objects.requireNonNull(listenerType, "[listenerType] must be non-null"); ListenerChain chain = (ListenerChain) suite.getAttribute(LISTENER_CHAIN); - for (ITestNGListener listener : chain.listeners) { + Objects.requireNonNull(chain, "Specified suite has no ListenerChain"); + return chain.getAttachedListener(listenerType); + } + + /** + * Get reference to an instance of the specified listener type. + * + * @param listener type + * @param listenerType listener type + * @return optional listener instance + */ + @SuppressWarnings("unchecked") + public Optional getAttachedListener(Class listenerType) { + for (ITestNGListener listener : listeners) { if (listener.getClass() == listenerType) { return Optional.of((T) listener); } @@ -591,7 +629,9 @@ public void onAfterClass(ITestClass testClass) { * @param testMethod test method */ private void attachListeners(Method testMethod) { - attachListeners(testMethod.getDeclaringClass()); + if (testMethod != null) { + processLinkedListeners(testMethod.getDeclaringClass()); + } } /** @@ -606,11 +646,11 @@ private void attachListeners(Method testMethod) { */ private void attachListeners(Class testClass, Constructor testCtor, Method testMethod) { if (testClass != null) { - attachListeners(testClass); + processLinkedListeners(testClass); } else if (testCtor != null) { - attachListeners(testCtor.getDeclaringClass()); - } else { - attachListeners(testMethod.getDeclaringClass()); + processLinkedListeners(testCtor.getDeclaringClass()); + } else if (testMethod != null) { + processLinkedListeners(testMethod.getDeclaringClass()); } } @@ -620,6 +660,19 @@ private void attachListeners(Class testClass, Constructor testCtor, Method * @param testClass test class */ private void attachListeners(Class testClass) { + if (testClass != null) { + processLinkedListeners(testClass); + } + } + + /** + * Process the {@link LinkedListeners} annotation of the specified test class. + * + * @param testClass test class + */ + private void processLinkedListeners(Class testClass) { + Objects.requireNonNull(testClass, "[testClass] must be non-null"); + LinkedListeners annotation = testClass.getAnnotation(LinkedListeners.class); if (null != annotation) { Class markedClass = testClass; diff --git a/src/test/java/com/nordstrom/automation/testng/ChainedListener.java b/src/test/java/com/nordstrom/automation/testng/ChainedListener.java index 32dcfb3..8775350 100644 --- a/src/test/java/com/nordstrom/automation/testng/ChainedListener.java +++ b/src/test/java/com/nordstrom/automation/testng/ChainedListener.java @@ -30,39 +30,39 @@ public class ChainedListener implements IAnnotationTransformer3, ISuiteListener, IConfigurationListener2, IInvokedMethodListener, ITestListener, IMethodInterceptor, IClassListener { - static Set configSuccess = Collections.synchronizedSet(new HashSet<>()); - static Set configFailure = Collections.synchronizedSet(new HashSet<>()); - static Set configSkipped = Collections.synchronizedSet(new HashSet<>()); - static Set beforeConfig = Collections.synchronizedSet(new HashSet<>()); + Set configSuccess = Collections.synchronizedSet(new HashSet<>()); + Set configFailure = Collections.synchronizedSet(new HashSet<>()); + Set configSkipped = Collections.synchronizedSet(new HashSet<>()); + Set beforeConfig = Collections.synchronizedSet(new HashSet<>()); - static Set beforeMethodBefore = Collections.synchronizedSet(new HashSet<>()); - static Set beforeMethodAfter = Collections.synchronizedSet(new HashSet<>()); - static Set testMethodBefore = Collections.synchronizedSet(new HashSet<>()); - static Set testMethodAfter = Collections.synchronizedSet(new HashSet<>()); - static Set afterMethodBefore = Collections.synchronizedSet(new HashSet<>()); - static Set afterMethodAfter = Collections.synchronizedSet(new HashSet<>()); + Set beforeMethodBefore = Collections.synchronizedSet(new HashSet<>()); + Set beforeMethodAfter = Collections.synchronizedSet(new HashSet<>()); + Set testMethodBefore = Collections.synchronizedSet(new HashSet<>()); + Set testMethodAfter = Collections.synchronizedSet(new HashSet<>()); + Set afterMethodBefore = Collections.synchronizedSet(new HashSet<>()); + Set afterMethodAfter = Collections.synchronizedSet(new HashSet<>()); - static Set beforeClass = Collections.synchronizedSet(new HashSet<>()); - static Set afterClass = Collections.synchronizedSet(new HashSet<>()); + Set beforeClass = Collections.synchronizedSet(new HashSet<>()); + Set afterClass = Collections.synchronizedSet(new HashSet<>()); - static Set testStarted = Collections.synchronizedSet(new HashSet<>()); - static Set testSuccess = Collections.synchronizedSet(new HashSet<>()); - static Set testFailure = Collections.synchronizedSet(new HashSet<>()); - static Set testSkipped = Collections.synchronizedSet(new HashSet<>()); - static Set testCurved = Collections.synchronizedSet(new HashSet<>()); - static Set testsBegun = Collections.synchronizedSet(new HashSet<>()); - static Set testsEnded = Collections.synchronizedSet(new HashSet<>()); + Set testStarted = Collections.synchronizedSet(new HashSet<>()); + Set testSuccess = Collections.synchronizedSet(new HashSet<>()); + Set testFailure = Collections.synchronizedSet(new HashSet<>()); + Set testSkipped = Collections.synchronizedSet(new HashSet<>()); + Set testCurved = Collections.synchronizedSet(new HashSet<>()); + Set testsBegun = Collections.synchronizedSet(new HashSet<>()); + Set testsEnded = Collections.synchronizedSet(new HashSet<>()); - static Set suiteBegun = Collections.synchronizedSet(new HashSet<>()); - static Set suiteEnded = Collections.synchronizedSet(new HashSet<>()); + Set suiteBegun = Collections.synchronizedSet(new HashSet<>()); + Set suiteEnded = Collections.synchronizedSet(new HashSet<>()); - static Set xformTest = Collections.synchronizedSet(new HashSet<>()); - static Set xformConfig = Collections.synchronizedSet(new HashSet<>()); - static Set xformProvider = Collections.synchronizedSet(new HashSet<>()); - static Set xformFactory = Collections.synchronizedSet(new HashSet<>()); - static Set xformListeners = Collections.synchronizedSet(new HashSet<>()); + Set xformTest = Collections.synchronizedSet(new HashSet<>()); + Set xformConfig = Collections.synchronizedSet(new HashSet<>()); + Set xformProvider = Collections.synchronizedSet(new HashSet<>()); + Set xformFactory = Collections.synchronizedSet(new HashSet<>()); + Set xformListeners = Collections.synchronizedSet(new HashSet<>()); - static Set interceptor = Collections.synchronizedSet(new HashSet<>()); + Set interceptor = Collections.synchronizedSet(new HashSet<>()); @Override public void onConfigurationSuccess(ITestResult itr) { @@ -191,18 +191,22 @@ public void transform(IConfigurationAnnotation annotation, Class testClass, @Override public void transform(IDataProviderAnnotation annotation, Method method) { - xformProvider.add(method.getName()); + xformProvider.add("method: " + method.getName()); } @Override public void transform(IFactoryAnnotation annotation, Method method) { - xformFactory.add(method.getName()); + if (method != null) { + xformFactory.add("method: " + method.getName()); + } else { + xformFactory.add("ctor: (unknown)"); + } } @SuppressWarnings("rawtypes") @Override public void transform(IListenersAnnotation annotation, Class testClass) { - xformListeners.add(testClass.getSimpleName()); + xformListeners.add("class: " + testClass.getSimpleName()); } @Override diff --git a/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java b/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java index cef56ea..2547e9f 100644 --- a/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java +++ b/src/test/java/com/nordstrom/automation/testng/ConstructorFactory.java @@ -1,19 +1,27 @@ -package com.nordstrom.automation.testng; - -import org.testng.annotations.DataProvider; -import org.testng.annotations.Factory; -import org.testng.annotations.Test; - -public class ConstructorFactory { - - public ConstructorFactory(){} - - @DataProvider - public Object[] ints(){return new Object[]{1, 2, 3};} - - @Factory(dataProvider = "ints", dataProviderClass = ConstructorFactory.class) - public ConstructorFactory(int i){ } - - @Test - public void test(){} -} +package com.nordstrom.automation.testng; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Factory; +import org.testng.annotations.Test; + +@LinkedListeners({ChainedListener.class, ExecutionFlowController.class}) +public class ConstructorFactory { + + public ConstructorFactory() { + } + + @Factory(dataProvider = "ints") + public ConstructorFactory(final int i) { + // not important + } + + @DataProvider + public Object[] ints() { + return new Object[]{1, 2, 3}; + } + + @Test + public void fakeTest() { + // not important + } +} diff --git a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java index 7c21f57..8d40a61 100644 --- a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java +++ b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java @@ -27,6 +27,8 @@ public void verifyHappyPath() { testNG.setGroups("happyPath"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 2, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); @@ -34,29 +36,29 @@ public void verifyHappyPath() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configSuccess.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterSuccess")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configSuccess.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterSuccess")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("happyPath")); - assertTrue(ChainedListener.testMethodAfter.contains("happyPath")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterSuccess")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterSuccess")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("happyPath")); + assertTrue(chainedListener.testMethodAfter.contains("happyPath")); + assertTrue(chainedListener.afterMethodBefore.contains("afterSuccess")); + assertTrue(chainedListener.afterMethodAfter.contains("afterSuccess")); - assertTrue(ChainedListener.testStarted.contains("happyPath")); - assertTrue(ChainedListener.testSuccess.contains("happyPath")); + assertTrue(chainedListener.testStarted.contains("happyPath")); + assertTrue(chainedListener.testSuccess.contains("happyPath")); - assertTrue(ChainedListener.beforeClass.contains("ListenerChainTestCases")); - assertTrue(ChainedListener.afterClass.contains("ListenerChainTestCases")); + assertTrue(chainedListener.beforeClass.contains("ListenerChainTestCases")); + assertTrue(chainedListener.afterClass.contains("ListenerChainTestCases")); - assertTrue(ChainedListener.testsBegun.contains("Command line test")); - assertTrue(ChainedListener.testsEnded.contains("Command line test")); + assertTrue(chainedListener.testsBegun.contains("Command line test")); + assertTrue(chainedListener.testsEnded.contains("Command line test")); - assertTrue(ChainedListener.suiteBegun.contains("Command line suite")); - assertTrue(ChainedListener.suiteEnded.contains("Command line suite")); + assertTrue(chainedListener.suiteBegun.contains("Command line suite")); + assertTrue(chainedListener.suiteEnded.contains("Command line suite")); Set expectTests = new HashSet<>(Arrays.asList("method: testSkipped", "method: happyPath", "method: beforeSuccess", "method: beforeSkipped", @@ -70,13 +72,13 @@ public void verifyHappyPath() { "method: afterFailure", "method: beforeSuccess", "method: beforeFailure", "method: beforeSkipped", "method: afterSkipped")); - assertEquals(ChainedListener.xformTest, expectTests); - assertEquals(ChainedListener.xformConfig, expectConfigs); - assertTrue(ChainedListener.xformProvider.contains("dataProvider")); - assertTrue(ChainedListener.xformFactory.contains("createInstances")); - assertTrue(ChainedListener.xformListeners.contains("ListenerChainTestCases")); + assertEquals(chainedListener.xformTest, expectTests); + assertEquals(chainedListener.xformConfig, expectConfigs); + assertTrue(chainedListener.xformProvider.contains("method: dataProvider")); + assertTrue(chainedListener.xformFactory.contains("method: createInstances")); + assertTrue(chainedListener.xformListeners.contains("class: ListenerChainTestCases")); - assertTrue(ChainedListener.interceptor.contains("Command line test")); + assertTrue(chainedListener.interceptor.contains("Command line test")); } @Test @@ -92,6 +94,8 @@ public void verifyTestFailed() { testNG.setGroups("testFailed"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 0, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 1, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); @@ -99,20 +103,20 @@ public void verifyTestFailed() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configSuccess.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterSuccess")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configSuccess.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterSuccess")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("testFailed")); - assertTrue(ChainedListener.testMethodAfter.contains("testFailed")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterSuccess")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterSuccess")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("testFailed")); + assertTrue(chainedListener.testMethodAfter.contains("testFailed")); + assertTrue(chainedListener.afterMethodBefore.contains("afterSuccess")); + assertTrue(chainedListener.afterMethodAfter.contains("afterSuccess")); - assertTrue(ChainedListener.testStarted.contains("testFailed")); - assertTrue(ChainedListener.testFailure.contains("testFailed")); + assertTrue(chainedListener.testStarted.contains("testFailed")); + assertTrue(chainedListener.testFailure.contains("testFailed")); } @@ -129,6 +133,8 @@ public void verifyTestSkipped() { testNG.setGroups("testSkipped"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 0, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 1, "Incorrect skipped test count"); @@ -136,20 +142,20 @@ public void verifyTestSkipped() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configSuccess.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterSuccess")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configSuccess.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterSuccess")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("testSkipped")); - assertTrue(ChainedListener.testMethodAfter.contains("testSkipped")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterSuccess")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterSuccess")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("testSkipped")); + assertTrue(chainedListener.testMethodAfter.contains("testSkipped")); + assertTrue(chainedListener.afterMethodBefore.contains("afterSuccess")); + assertTrue(chainedListener.afterMethodAfter.contains("afterSuccess")); - assertTrue(ChainedListener.testStarted.contains("testSkipped")); - assertTrue(ChainedListener.testSkipped.contains("testSkipped")); + assertTrue(chainedListener.testStarted.contains("testSkipped")); + assertTrue(chainedListener.testSkipped.contains("testSkipped")); } @@ -166,6 +172,8 @@ public void verifyFailAndPass() { testNG.setGroups("failAndPass"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 3, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); @@ -173,20 +181,20 @@ public void verifyFailAndPass() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configSuccess.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterSuccess")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configSuccess.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterSuccess")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("failAndPass")); - assertTrue(ChainedListener.testMethodAfter.contains("failAndPass")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterSuccess")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterSuccess")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("failAndPass")); + assertTrue(chainedListener.testMethodAfter.contains("failAndPass")); + assertTrue(chainedListener.afterMethodBefore.contains("afterSuccess")); + assertTrue(chainedListener.afterMethodAfter.contains("afterSuccess")); - assertTrue(ChainedListener.testStarted.contains("failAndPass")); - assertTrue(ChainedListener.testCurved.contains("failAndPass")); + assertTrue(chainedListener.testStarted.contains("failAndPass")); + assertTrue(chainedListener.testCurved.contains("failAndPass")); } @@ -203,6 +211,8 @@ public void verifyBeforeFailed() { testNG.setGroups("beforeFailed"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 0, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 1, "Incorrect skipped test count"); @@ -210,17 +220,17 @@ public void verifyBeforeFailed() { assertEquals(tla.getConfigurationFailures().size(), 1, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 1, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configFailure.contains("beforeFailure")); - assertTrue(ChainedListener.configSkipped.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeFailure")); + assertTrue(chainedListener.configFailure.contains("beforeFailure")); + assertTrue(chainedListener.configSkipped.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeFailure")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeFailure")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeFailure")); - assertTrue(ChainedListener.testMethodBefore.contains("skipBeforeFailed")); - assertTrue(ChainedListener.testMethodAfter.contains("skipBeforeFailed")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeFailure")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeFailure")); + assertTrue(chainedListener.testMethodBefore.contains("skipBeforeFailed")); + assertTrue(chainedListener.testMethodAfter.contains("skipBeforeFailed")); - assertTrue(ChainedListener.testStarted.contains("skipBeforeFailed")); - assertTrue(ChainedListener.testSkipped.contains("skipBeforeFailed")); + assertTrue(chainedListener.testStarted.contains("skipBeforeFailed")); + assertTrue(chainedListener.testSkipped.contains("skipBeforeFailed")); } @@ -237,6 +247,8 @@ public void verifyBeforeSkipped() { testNG.setGroups("beforeSkipped"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 0, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 1, "Incorrect skipped test count"); @@ -244,17 +256,17 @@ public void verifyBeforeSkipped() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 2, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSkipped.contains("beforeSkipped")); - assertTrue(ChainedListener.configSkipped.contains("afterSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSkipped")); + assertTrue(chainedListener.configSkipped.contains("beforeSkipped")); + assertTrue(chainedListener.configSkipped.contains("afterSuccess")); + assertTrue(chainedListener.beforeConfig.contains("beforeSkipped")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSkipped")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSkipped")); - assertTrue(ChainedListener.testMethodBefore.contains("skipBeforeSkipped")); - assertTrue(ChainedListener.testMethodAfter.contains("skipBeforeSkipped")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSkipped")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSkipped")); + assertTrue(chainedListener.testMethodBefore.contains("skipBeforeSkipped")); + assertTrue(chainedListener.testMethodAfter.contains("skipBeforeSkipped")); - assertTrue(ChainedListener.testStarted.contains("skipBeforeSkipped")); - assertTrue(ChainedListener.testSkipped.contains("skipBeforeSkipped")); + assertTrue(chainedListener.testStarted.contains("skipBeforeSkipped")); + assertTrue(chainedListener.testSkipped.contains("skipBeforeSkipped")); } @@ -271,6 +283,8 @@ public void verifyAfterFailed() { testNG.setGroups("afterFailed"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 1, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); @@ -278,20 +292,20 @@ public void verifyAfterFailed() { assertEquals(tla.getConfigurationFailures().size(), 1, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configFailure.contains("afterFailure")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterFailure")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configFailure.contains("afterFailure")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterFailure")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("testAfterFailed")); - assertTrue(ChainedListener.testMethodAfter.contains("testAfterFailed")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterFailure")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterFailure")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("testAfterFailed")); + assertTrue(chainedListener.testMethodAfter.contains("testAfterFailed")); + assertTrue(chainedListener.afterMethodBefore.contains("afterFailure")); + assertTrue(chainedListener.afterMethodAfter.contains("afterFailure")); - assertTrue(ChainedListener.testStarted.contains("testAfterFailed")); - assertTrue(ChainedListener.testSuccess.contains("testAfterFailed")); + assertTrue(chainedListener.testStarted.contains("testAfterFailed")); + assertTrue(chainedListener.testSuccess.contains("testAfterFailed")); } @@ -308,6 +322,8 @@ public void verifyAfterSkipped() { testNG.setGroups("afterSkipped"); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 1, "Incorrect passed test count"); assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); @@ -315,20 +331,20 @@ public void verifyAfterSkipped() { assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); assertEquals(tla.getConfigurationSkips().size(), 1, "Incorrect configuration method skip count"); - assertTrue(ChainedListener.configSuccess.contains("beforeSuccess")); - assertTrue(ChainedListener.configSkipped.contains("afterSkipped")); - assertTrue(ChainedListener.beforeConfig.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeConfig.contains("afterSkipped")); + assertTrue(chainedListener.configSuccess.contains("beforeSuccess")); + assertTrue(chainedListener.configSkipped.contains("afterSkipped")); + assertTrue(chainedListener.beforeConfig.contains("beforeSuccess")); + assertTrue(chainedListener.beforeConfig.contains("afterSkipped")); - assertTrue(ChainedListener.beforeMethodBefore.contains("beforeSuccess")); - assertTrue(ChainedListener.beforeMethodAfter.contains("beforeSuccess")); - assertTrue(ChainedListener.testMethodBefore.contains("testAfterSkipped")); - assertTrue(ChainedListener.testMethodAfter.contains("testAfterSkipped")); - assertTrue(ChainedListener.afterMethodBefore.contains("afterSkipped")); - assertTrue(ChainedListener.afterMethodAfter.contains("afterSkipped")); + assertTrue(chainedListener.beforeMethodBefore.contains("beforeSuccess")); + assertTrue(chainedListener.beforeMethodAfter.contains("beforeSuccess")); + assertTrue(chainedListener.testMethodBefore.contains("testAfterSkipped")); + assertTrue(chainedListener.testMethodAfter.contains("testAfterSkipped")); + assertTrue(chainedListener.afterMethodBefore.contains("afterSkipped")); + assertTrue(chainedListener.afterMethodAfter.contains("afterSkipped")); - assertTrue(ChainedListener.testStarted.contains("testAfterSkipped")); - assertTrue(ChainedListener.testSuccess.contains("testAfterSkipped")); + assertTrue(chainedListener.testStarted.contains("testAfterSkipped")); + assertTrue(chainedListener.testSuccess.contains("testAfterSkipped")); } @@ -343,7 +359,35 @@ public void verifyConstructorFactory(){ testNG.addListener((ITestNGListener) tla); testNG.run(); + ChainedListener chainedListener = lc.getAttachedListener(ChainedListener.class).get(); + assertEquals(tla.getPassedTests().size(), 3, "Incorrect passed test count"); + assertEquals(tla.getFailedTests().size(), 0, "Incorrect failed test count"); + assertEquals(tla.getSkippedTests().size(), 0, "Incorrect skipped test count"); + assertEquals(tla.getFailedButWithinSuccessPercentageTests().size(), 0, "Incorrect curve-graded success count"); + assertEquals(tla.getConfigurationFailures().size(), 0, "Incorrect configuration method failure count"); + assertEquals(tla.getConfigurationSkips().size(), 0, "Incorrect configuration method skip count"); + + assertTrue(chainedListener.testMethodBefore.contains("fakeTest")); + assertTrue(chainedListener.testMethodAfter.contains("fakeTest")); + + assertTrue(chainedListener.testStarted.contains("fakeTest")); + assertTrue(chainedListener.testSuccess.contains("fakeTest")); + + assertTrue(chainedListener.beforeClass.contains("ConstructorFactory")); + assertTrue(chainedListener.afterClass.contains("ConstructorFactory")); + + assertTrue(chainedListener.testsBegun.contains("Command line test")); + assertTrue(chainedListener.testsEnded.contains("Command line test")); + + assertTrue(chainedListener.suiteBegun.contains("Command line suite")); + assertTrue(chainedListener.suiteEnded.contains("Command line suite")); + + assertTrue(chainedListener.xformTest.contains("method: fakeTest")); + assertTrue(chainedListener.xformProvider.contains("method: ints")); + assertTrue(chainedListener.xformFactory.contains("ctor: (unknown)")); + + assertTrue(chainedListener.interceptor.contains("Command line test")); } } From 3608ed2b295b5847dac848f5450e6a4741ac8bba Mon Sep 17 00:00:00 2001 From: Scott Babcock Date: Mon, 8 Jan 2018 15:13:29 -0800 Subject: [PATCH 4/5] Fix line endings --- .../automation/testng/ListenerChain.java | 66 +++++++++---------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java index 305d609..b77bf1a 100644 --- a/src/main/java/com/nordstrom/automation/testng/ListenerChain.java +++ b/src/main/java/com/nordstrom/automation/testng/ListenerChain.java @@ -3,40 +3,40 @@ import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Objects; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Objects; import java.util.Optional; -import java.util.ServiceLoader; -import java.util.Set; - -import org.testng.IAnnotationTransformer; -import org.testng.IAnnotationTransformer2; -import org.testng.IAnnotationTransformer3; -import org.testng.IClassListener; -import org.testng.IConfigurationListener; -import org.testng.IConfigurationListener2; -import org.testng.IInvokedMethod; -import org.testng.IInvokedMethodListener; -import org.testng.IInvokedMethodListener2; -import org.testng.IMethodInstance; -import org.testng.IMethodInterceptor; -import org.testng.ISuite; -import org.testng.ISuiteListener; -import org.testng.ITestClass; -import org.testng.ITestContext; -import org.testng.ITestListener; -import org.testng.ITestNGListener; -import org.testng.ITestResult; -import org.testng.annotations.IConfigurationAnnotation; -import org.testng.annotations.IDataProviderAnnotation; -import org.testng.annotations.IFactoryAnnotation; -import org.testng.annotations.IListenersAnnotation; -import org.testng.annotations.ITestAnnotation; -import org.testng.internal.InvokedMethod; - +import java.util.ServiceLoader; +import java.util.Set; + +import org.testng.IAnnotationTransformer; +import org.testng.IAnnotationTransformer2; +import org.testng.IAnnotationTransformer3; +import org.testng.IClassListener; +import org.testng.IConfigurationListener; +import org.testng.IConfigurationListener2; +import org.testng.IInvokedMethod; +import org.testng.IInvokedMethodListener; +import org.testng.IInvokedMethodListener2; +import org.testng.IMethodInstance; +import org.testng.IMethodInterceptor; +import org.testng.ISuite; +import org.testng.ISuiteListener; +import org.testng.ITestClass; +import org.testng.ITestContext; +import org.testng.ITestListener; +import org.testng.ITestNGListener; +import org.testng.ITestResult; +import org.testng.annotations.IConfigurationAnnotation; +import org.testng.annotations.IDataProviderAnnotation; +import org.testng.annotations.IFactoryAnnotation; +import org.testng.annotations.IListenersAnnotation; +import org.testng.annotations.ITestAnnotation; +import org.testng.internal.InvokedMethod; + import com.google.common.collect.Lists; /** From 02be88cdc83dacae4983e7e5b207bb80ffdbfb7e Mon Sep 17 00:00:00 2001 From: Scott Babcock Date: Mon, 8 Jan 2018 15:17:10 -0800 Subject: [PATCH 5/5] Undo unintended import re-ordering --- .../automation/testng/ListenerChainTest.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java index 8d40a61..baf943e 100644 --- a/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java +++ b/src/test/java/com/nordstrom/automation/testng/ListenerChainTest.java @@ -1,16 +1,16 @@ package com.nordstrom.automation.testng; -import org.testng.ITestNGListener; -import org.testng.TestListenerAdapter; -import org.testng.TestNG; -import org.testng.annotations.Test; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertTrue; import java.util.Arrays; import java.util.HashSet; import java.util.Set; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; +import org.testng.ITestNGListener; +import org.testng.TestListenerAdapter; +import org.testng.TestNG; +import org.testng.annotations.Test; public class ListenerChainTest {