diff options
12 files changed, 1187 insertions, 1203 deletions
@@ -25,7 +25,7 @@ <parent> <groupId>org.onap.oparent</groupId> <artifactId>oparent</artifactId> - <version>0.1.1</version> + <version>1.1.0</version> <relativePath /> </parent> diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java index 27387bfd..710926d3 100644 --- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java +++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java @@ -20,18 +20,15 @@ package org.onap.policy.common.utils.test; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import org.junit.Test; -/** - * - */ public class ConstructionErrorTest extends ErrorsTester { - @Test - public void test() throws Exception { - assertEquals(4, testAllError(ConstructionError.class)); - } + @Test + public void test() throws Exception { + assertEquals(4, testAllError(ConstructionError.class)); + } } diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java index 60aed22d..2009e297 100644 --- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java +++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java @@ -26,52 +26,52 @@ import org.junit.Test; public class ErrorsTesterTest { - @Test - public void test() { - assertEquals(2, new ErrorsTester().testAllError(SimpleError.class)); - assertEquals(5, new ErrorsTester().testAllError(StaticError.class)); - } + @Test + public void test() { + assertEquals(2, new ErrorsTester().testAllError(SimpleError.class)); + assertEquals(5, new ErrorsTester().testAllError(StaticError.class)); + } - /** - * Used to test a simple success case. - */ - public static class SimpleError extends Error { - private static final long serialVersionUID = 1L; + /** + * Used to test a simple success case. + */ + public static class SimpleError extends Error { + private static final long serialVersionUID = 1L; - public SimpleError() { - super(); - } + public SimpleError() { + super(); + } - public SimpleError(String message) { - super(message); - } - } + public SimpleError(String message) { + super(message); + } + } - /** - * Used to test the exhaustive success case. - */ - public static class StaticError extends Error { - private static final long serialVersionUID = 1L; + /** + * Used to test the exhaustive success case. + */ + public static class StaticError extends Error { + private static final long serialVersionUID = 1L; - public StaticError() { - super(); - } + public StaticError() { + super(); + } - public StaticError(String message) { - super(message); - } + public StaticError(String message) { + super(message); + } - public StaticError(Throwable cause) { - super(cause); - } + public StaticError(Throwable cause) { + super(cause); + } - public StaticError(String message, Throwable cause) { - super(message, cause); - } + public StaticError(String message, Throwable cause) { + super(message, cause); + } - public StaticError(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { - super(message, cause, enableSuppression, writableStackTrace); - } - } + public StaticError(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + } } diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java index b9975227..89ff3ba1 100644 --- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java +++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java @@ -26,84 +26,83 @@ import org.junit.Test; public class ExceptionsTesterTest { - @Test - public void test() { - assertEquals(2, new ExceptionsTester().test(SimpleException.class)); - assertEquals(8, new ExceptionsTester().test(StaticException.class)); - } - - @Test(expected = AssertionError.class) - public void testNoConstructorsException() { - new ExceptionsTester().test(NoConstructorsException.class); - } - - /** - * Used to test a failure case - this has no standard constructors. The only - * constructor it has takes an "int", thus it is not one of the standard - * constructors. - */ - public static class NoConstructorsException extends Exception { - private static final long serialVersionUID = 1L; - - public NoConstructorsException(int value) { - super(); - } - } - - /** - * Used to test a simple success case. - */ - public static class SimpleException extends Exception { - private static final long serialVersionUID = 1L; - - public SimpleException() { - super(); - } - - public SimpleException(String message) { - super(message); - } - } - - /** - * Used to test the exhaustive success case. - */ - public static class StaticException extends Exception { - private static final long serialVersionUID = 1L; - - public StaticException() { - super(); - } - - public StaticException(String message) { - super(message); - } - - public StaticException(Throwable cause) { - super(cause); - } - - public StaticException(String message, Throwable cause) { - super(message, cause); - } - - public StaticException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { - super(message, cause, enableSuppression, writableStackTrace); - } - - // same as above, but with Exceptions substituted for Throwables - - public StaticException(Exception cause) { - super(cause); - } - - public StaticException(String message, Exception cause) { - super(message, cause); - } - - public StaticException(String message, Exception cause, boolean enableSuppression, boolean writableStackTrace) { - super(message, cause, enableSuppression, writableStackTrace); - } - } + @Test + public void test() { + assertEquals(2, new ExceptionsTester().test(SimpleException.class)); + assertEquals(8, new ExceptionsTester().test(StaticException.class)); + } + + @Test(expected = AssertionError.class) + public void testNoConstructorsException() { + new ExceptionsTester().test(NoConstructorsException.class); + } + + /** + * Used to test a failure case - this has no standard constructors. The only constructor it has + * takes an "int", thus it is not one of the standard constructors. + */ + public static class NoConstructorsException extends Exception { + private static final long serialVersionUID = 1L; + + public NoConstructorsException(int value) { + super(); + } + } + + /** + * Used to test a simple success case. + */ + public static class SimpleException extends Exception { + private static final long serialVersionUID = 1L; + + public SimpleException() { + super(); + } + + public SimpleException(String message) { + super(message); + } + } + + /** + * Used to test the exhaustive success case. + */ + public static class StaticException extends Exception { + private static final long serialVersionUID = 1L; + + public StaticException() { + super(); + } + + public StaticException(String message) { + super(message); + } + + public StaticException(Throwable cause) { + super(cause); + } + + public StaticException(String message, Throwable cause) { + super(message, cause); + } + + public StaticException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + + // same as above, but with Exceptions substituted for Throwables + + public StaticException(Exception cause) { + super(cause); + } + + public StaticException(String message, Exception cause) { + super(message, cause); + } + + public StaticException(String message, Exception cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + } } diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java index cb8c0ef6..4d289c6a 100644 --- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java +++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java @@ -26,191 +26,189 @@ import org.junit.Test; public class ThrowablesTesterTest { - @Test - public void test() { - assertEquals(2, new ThrowablesTester().testAllThrowable(SimpleThrowable.class)); - assertEquals(5, new ThrowablesTester().testAllThrowable(StaticThrowable.class)); - } - - @Test - public void testNoConstructorsThrowable() { - // this will not throw an error, but it should return 0, as there are - // no matching constructors - assertEquals(0, new ThrowablesTester().testAllThrowable(NoConstructorsThrowable.class)); - } - - @Test(expected = AssertionError.class) - public void testIgnoreMessageThrowable() { - new ThrowablesTester().testAllThrowable(IgnoreMessageThrowable.class); - } - - @Test(expected = AssertionError.class) - public void testIgnoreCauseThrowable() { - new ThrowablesTester().testAllThrowable(IgnoreCauseThrowable.class); - } - - @Test(expected = AssertionError.class) - public void testAlwaysSuppressThrowable() { - new ThrowablesTester().testAllThrowable(AlwaysSuppressThrowable.class); - } - - @Test(expected = AssertionError.class) - public void testNeverSuppressThrowable() { - new ThrowablesTester().testAllThrowable(NeverSuppressThrowable.class); - } - - @Test(expected = AssertionError.class) - public void testAlwaysWritableThrowable() { - new ThrowablesTester().testAllThrowable(AlwaysWritableThrowable.class); - } - - @Test(expected = AssertionError.class) - public void testNeverWritableThrowable() { - new ThrowablesTester().testAllThrowable(NeverWritableThrowable.class); - } - - @Test(expected = ConstructionError.class) - public void testThrowInstantiationException() { - new ThrowablesTester().testAllThrowable(ThrowInstantiationException.class); - } - - /** - * Used to test a failure case - message text is ignored. - */ - public static class IgnoreMessageThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public IgnoreMessageThrowable(String message) { - super("bogus"); - } - } - - /** - * Used to test a failure case - cause is ignored. - */ - public static class IgnoreCauseThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public IgnoreCauseThrowable(Throwable cause) { - super(new Throwable("another cause")); - } - } - - /** - * Used to test a failure case - this has no standard constructors. The only - * constructor it has takes an "int", thus it is not one of the standard - * constructors. - */ - public static class NoConstructorsThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public NoConstructorsThrowable(int value) { - super(); - } - } - - /** - * Used to test a failure case - always suppresses. - */ - public static class AlwaysSuppressThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public AlwaysSuppressThrowable(String message, Throwable cause, boolean enableSuppression, - boolean writableStackTrace) { - super(message, cause, true, writableStackTrace); - } - } - - /** - * Used to test a failure case - never suppresses. - */ - public static class NeverSuppressThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public NeverSuppressThrowable(String message, Throwable cause, boolean enableSuppression, - boolean writableStackTrace) { - super(message, cause, false, writableStackTrace); - } - } - - /** - * Used to test a failure case - always allows stack writes. - */ - public static class AlwaysWritableThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public AlwaysWritableThrowable(String message, Throwable cause, boolean enableSuppression, - boolean writableStackTrace) { - super(message, cause, enableSuppression, true); - } - } - - /** - * Used to test a failure case - never allows stack writes. - */ - public static class NeverWritableThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public NeverWritableThrowable(String message, Throwable cause, boolean enableSuppression, - boolean writableStackTrace) { - super(message, cause, enableSuppression, false); - } - } - - /** - * Used to test a failure case - throws InstantiationException when - * constructed. - */ - public static class ThrowInstantiationException extends Throwable { - private static final long serialVersionUID = 1L; - - public ThrowInstantiationException(String message, Throwable cause, boolean enableSuppression, - boolean writableStackTrace) throws InstantiationException { - - throw new InstantiationException(ThrowablesTester.EXPECTED_EXCEPTION_MSG); - } - } - - /** - * Used to test a simple success case. - */ - public static class SimpleThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public SimpleThrowable() { - super(); - } - - public SimpleThrowable(String message) { - super(message); - } - } - - /** - * Used to test the exhaustive success case. - */ - public static class StaticThrowable extends Throwable { - private static final long serialVersionUID = 1L; - - public StaticThrowable() { - super(); - } - - public StaticThrowable(String message) { - super(message); - } - - public StaticThrowable(Throwable cause) { - super(cause); - } - - public StaticThrowable(String message, Throwable cause) { - super(message, cause); - } - - public StaticThrowable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { - super(message, cause, enableSuppression, writableStackTrace); - } - } + @Test + public void test() { + assertEquals(2, new ThrowablesTester().testAllThrowable(SimpleThrowable.class)); + assertEquals(5, new ThrowablesTester().testAllThrowable(StaticThrowable.class)); + } + + @Test + public void testNoConstructorsThrowable() { + // this will not throw an error, but it should return 0, as there are + // no matching constructors + assertEquals(0, new ThrowablesTester().testAllThrowable(NoConstructorsThrowable.class)); + } + + @Test(expected = AssertionError.class) + public void testIgnoreMessageThrowable() { + new ThrowablesTester().testAllThrowable(IgnoreMessageThrowable.class); + } + + @Test(expected = AssertionError.class) + public void testIgnoreCauseThrowable() { + new ThrowablesTester().testAllThrowable(IgnoreCauseThrowable.class); + } + + @Test(expected = AssertionError.class) + public void testAlwaysSuppressThrowable() { + new ThrowablesTester().testAllThrowable(AlwaysSuppressThrowable.class); + } + + @Test(expected = AssertionError.class) + public void testNeverSuppressThrowable() { + new ThrowablesTester().testAllThrowable(NeverSuppressThrowable.class); + } + + @Test(expected = AssertionError.class) + public void testAlwaysWritableThrowable() { + new ThrowablesTester().testAllThrowable(AlwaysWritableThrowable.class); + } + + @Test(expected = AssertionError.class) + public void testNeverWritableThrowable() { + new ThrowablesTester().testAllThrowable(NeverWritableThrowable.class); + } + + @Test(expected = ConstructionError.class) + public void testThrowInstantiationException() { + new ThrowablesTester().testAllThrowable(ThrowInstantiationException.class); + } + + /** + * Used to test a failure case - message text is ignored. + */ + public static class IgnoreMessageThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public IgnoreMessageThrowable(String message) { + super("bogus"); + } + } + + /** + * Used to test a failure case - cause is ignored. + */ + public static class IgnoreCauseThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public IgnoreCauseThrowable(Throwable cause) { + super(new Throwable("another cause")); + } + } + + /** + * Used to test a failure case - this has no standard constructors. The only constructor it has + * takes an "int", thus it is not one of the standard constructors. + */ + public static class NoConstructorsThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public NoConstructorsThrowable(int value) { + super(); + } + } + + /** + * Used to test a failure case - always suppresses. + */ + public static class AlwaysSuppressThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public AlwaysSuppressThrowable(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, true, writableStackTrace); + } + } + + /** + * Used to test a failure case - never suppresses. + */ + public static class NeverSuppressThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public NeverSuppressThrowable(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, false, writableStackTrace); + } + } + + /** + * Used to test a failure case - always allows stack writes. + */ + public static class AlwaysWritableThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public AlwaysWritableThrowable(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, true); + } + } + + /** + * Used to test a failure case - never allows stack writes. + */ + public static class NeverWritableThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public NeverWritableThrowable(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, false); + } + } + + /** + * Used to test a failure case - throws InstantiationException when constructed. + */ + public static class ThrowInstantiationException extends Throwable { + private static final long serialVersionUID = 1L; + + public ThrowInstantiationException(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) throws InstantiationException { + + throw new InstantiationException(ThrowablesTester.EXPECTED_EXCEPTION_MSG); + } + } + + /** + * Used to test a simple success case. + */ + public static class SimpleThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public SimpleThrowable() { + super(); + } + + public SimpleThrowable(String message) { + super(message); + } + } + + /** + * Used to test the exhaustive success case. + */ + public static class StaticThrowable extends Throwable { + private static final long serialVersionUID = 1L; + + public StaticThrowable() { + super(); + } + + public StaticThrowable(String message) { + super(message); + } + + public StaticThrowable(Throwable cause) { + super(cause); + } + + public StaticThrowable(String message, Throwable cause) { + super(message, cause); + } + + public StaticThrowable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + } } diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java index 6ef36822..eee60c38 100644 --- a/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java +++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java @@ -23,6 +23,10 @@ package org.onap.policy.common.utils.test.log.logback; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.ILoggingEvent; + import java.util.Arrays; import java.util.LinkedList; import java.util.List; @@ -35,450 +39,440 @@ import org.junit.BeforeClass; import org.junit.Test; import org.slf4j.LoggerFactory; -import ch.qos.logback.classic.Level; -import ch.qos.logback.classic.Logger; -import ch.qos.logback.classic.spi.ILoggingEvent; - public class ExtractAppenderTest { - /** - * Milliseconds to wait for a thread to terminate. - */ - private static final long THREAD_WAIT_MS = 5000l; + /** + * Milliseconds to wait for a thread to terminate. + */ + private static final long THREAD_WAIT_MS = 5000L; + + private static Logger logger; + + private List<Thread> threads; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + logger = (Logger) LoggerFactory.getLogger(ExtractAppenderTest.class); + logger.setLevel(Level.INFO); + } + + @Before + public void setUp() throws Exception { + threads = new LinkedList<>(); + } + + /** + * Tear down all appenders and threads. + */ + @After + public void tearDown() throws Exception { + logger.detachAndStopAllAppenders(); + + for (Thread p : threads) { + p.interrupt(); + p.join(THREAD_WAIT_MS); + } + } + + @Test + public void testExtractAppender() { + AtomicInteger count = new AtomicInteger(0); + + ExtractAppender appender = new ExtractAppender() { + @Override + protected void append(ILoggingEvent event) { + count.incrementAndGet(); + super.append(event); + } + }; + + addAppender(appender); + + logger.info("hello"); + logger.info("world"); + + // "append" should always be called + assertEquals(2, count.get()); + + // appender with no patterns - everything should match + assertEquals(strList("hello", "world"), appender.getExtracted()); + + // add a pattern and verify match + appender.setPattern("abc[0-9]"); + logger.info("hello abc1"); + + // this should not match + logger.info("hello def2"); + + assertEquals(4, count.get()); + assertEquals(strList("hello", "world", "abc1"), appender.getExtracted()); + } + + @Test + public void testExtractAppenderStringArray() { + AtomicInteger count = new AtomicInteger(0); + + ExtractAppender appender = new ExtractAppender("abc[0-9]", "def[0-9]") { + @Override + protected void append(ILoggingEvent event) { + count.incrementAndGet(); + super.append(event); + } + }; + + addAppender(appender); + + logger.info("hello abc1 world"); + logger.info("world ghi2 world"); // no match + logger.info("world def3 world"); + logger.info("hello abc4"); + logger.info("abc5 world"); + logger.info("hello def6"); + logger.info("ghi7 world"); // no match + logger.info("def8 world"); + + // "append" should always be called + assertEquals(8, count.get()); + + assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8"), appender.getExtracted()); + + appender.setPattern("ghi[0-9]"); + logger.info("hello abc9"); + logger.info("hello ghi9"); + + // this should not match + logger.info("hello xyz"); + + assertEquals(11, count.get()); + assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8", "abc9", "ghi9"), appender.getExtracted()); + } + + @Test + public void testExtractAppenderQueueStringArray() { + // no. of matches allowed in the list + int nallowed = 3; + + AtomicInteger count = new AtomicInteger(0); + + LinkedList<String> queue = new LinkedList<String>() { + private static final long serialVersionUID = 1L; + + @Override + public boolean offer(String element) { + if (count.incrementAndGet() <= nallowed) { + return super.offer(element); + + } else { + return false; + } + } + }; + + ExtractAppender appender = new ExtractAppender(queue, "abc[0-9]"); + addAppender(appender); + + // these shouldn't match + for (int x = 0; x < 10; ++x) { + logger.info("xyz"); + } + + int nmatches = 10; + + LinkedList<String> expected = new LinkedList<>(); + + for (int x = 0; x < nmatches; ++x) { + String msg = "abc" + x; + logger.info(msg + " world"); + + if (x < nallowed) { + expected.add(msg); + } + } + + // "offer" should always be called for a match + assertEquals(nmatches, count.get()); + + assertEquals(expected, appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_NoPatterns() { + ExtractAppender appender = makeAppender(); + + logger.info("hello"); + logger.info("world"); + + assertEquals(strList("hello", "world"), appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_MatchFirstPattern() { + ExtractAppender appender = makeAppender("abc[0-9]", "def[0-9]"); + + logger.info("hello abc1"); + logger.info("world xyz2"); + + assertEquals(strList("abc1"), appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_MatchLastPattern() { + ExtractAppender appender = makeAppender("abc[0-9]", "def[0-9]"); + + logger.info("hello def1"); + logger.info("world xyz2"); + + assertEquals(strList("def1"), appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_Group1() { + ExtractAppender appender = makeAppender("hello (abc)|(xyz)", "def[0-9]"); + + logger.info("hello abc, world!"); + logger.info("world abc"); + + assertEquals(strList("abc"), appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_Group3() { + ExtractAppender appender = makeAppender("hello (abc)|(pdq)|(xyz)", "def[0-9]"); + + logger.info("say hello xyz, world!"); + logger.info("world abc"); + + assertEquals(strList("xyz"), appender.getExtracted()); + } + + @Test + public void testAppendILoggingEvent_NoGroup() { + ExtractAppender appender = makeAppender("hello abc"); + + logger.info("say hello abc, world!"); + logger.info("world abc"); + + assertEquals(strList("hello abc"), appender.getExtracted()); + } + + @Test + public void testGetExtracted() { + ExtractAppender appender = makeAppender("abc[1-9]"); + + logger.info("hello abc1 world"); + logger.info("world ghi2 world"); // no match + logger.info("hello abc3"); + + List<String> oldlst = appender.getExtracted(); + assertEquals(strList("abc1", "abc3"), oldlst); + assertEquals(oldlst, appender.getExtracted()); + + logger.info("abc9"); + assertEquals(strList("abc1", "abc3", "abc9"), appender.getExtracted()); + } + + @Test + public void testClearExtractions() { + final ExtractAppender appender = makeAppender("abc[1-9]"); + + logger.info("hello abc1 world"); + logger.info("world ghi2 world"); + logger.info("hello abc3"); + + assertEquals(strList("abc1", "abc3"), appender.getExtracted()); + + appender.clearExtractions(); + + // list should be empty now + assertEquals(strList(), appender.getExtracted()); + + logger.info("hello abc4 world"); + logger.info("world ghi5 world"); + logger.info("hello abc6"); + + // list should only contain the new items + assertEquals(strList("abc4", "abc6"), appender.getExtracted()); + } + + @Test + public void testSetPattern() { + final ExtractAppender appender = makeAppender("abc[1-9]"); + + logger.info("hello abc1 world"); + logger.info("world ghi2 world"); // no match + logger.info("hello abc3"); + + assertEquals(strList("abc1", "abc3"), appender.getExtracted()); - private static Logger logger; - - private List<Thread> threads; - - @BeforeClass - public static void setUpBeforeClass() throws Exception { - logger = (Logger) LoggerFactory.getLogger(ExtractAppenderTest.class); - logger.setLevel(Level.INFO); - } - - @Before - public void setUp() throws Exception { - threads = new LinkedList<>(); - } - - @After - public void tearDown() throws Exception { - logger.detachAndStopAllAppenders(); - - for (Thread p : threads) { - p.interrupt(); - p.join(THREAD_WAIT_MS); - } - } - - @Test - public void testExtractAppender() { - AtomicInteger count = new AtomicInteger(0); - - ExtractAppender p = new ExtractAppender() { - @Override - protected void append(ILoggingEvent event) { - count.incrementAndGet(); - super.append(event); - } - }; - - addAppender(p); - - logger.info("hello"); - logger.info("world"); - - // "append" should always be called - assertEquals(2, count.get()); - - // appender with no patterns - everything should match - assertEquals(strList("hello", "world"), p.getExtracted()); - - // add a pattern and verify match - p.setPattern("abc[0-9]"); - logger.info("hello abc1"); - - // this should not match - logger.info("hello def2"); - - assertEquals(4, count.get()); - assertEquals(strList("hello", "world", "abc1"), p.getExtracted()); - } - - @Test - public void testExtractAppenderStringArray() { - AtomicInteger count = new AtomicInteger(0); - - ExtractAppender p = new ExtractAppender("abc[0-9]", "def[0-9]") { - @Override - protected void append(ILoggingEvent event) { - count.incrementAndGet(); - super.append(event); - } - }; - - addAppender(p); - - logger.info("hello abc1 world"); - logger.info("world ghi2 world"); // no match - logger.info("world def3 world"); - logger.info("hello abc4"); - logger.info("abc5 world"); - logger.info("hello def6"); - logger.info("ghi7 world"); // no match - logger.info("def8 world"); - - // "append" should always be called - assertEquals(8, count.get()); - - assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8"), p.getExtracted()); - - p.setPattern("ghi[0-9]"); - logger.info("hello abc9"); - logger.info("hello ghi9"); - - // this should not match - logger.info("hello xyz"); - - assertEquals(11, count.get()); - assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8", "abc9", "ghi9"), p.getExtracted()); - } - - @Test - public void testExtractAppenderQueueStringArray() { - // no. of matches allowed in the list - int nallowed = 3; - - AtomicInteger count = new AtomicInteger(0); - - LinkedList<String> queue = new LinkedList<String>() { - private static final long serialVersionUID = 1L; - - @Override - public boolean offer(String e) { - if(count.incrementAndGet() <= nallowed) { - return super.offer(e); - - } else { - return false; - } - } - }; - - ExtractAppender p = new ExtractAppender(queue, "abc[0-9]"); - addAppender(p); - - // these shouldn't match - for(int x = 0; x < 10; ++x) { - logger.info("xyz"); - } - - int nmatches = 10; - - LinkedList<String> expected = new LinkedList<>(); - - for(int x = 0; x < nmatches; ++x) { - String msg = "abc" + x; - logger.info(msg + " world"); - - if(x < nallowed) { - expected.add(msg); - } - } - - // "offer" should always be called for a match - assertEquals(nmatches, count.get()); - - assertEquals(expected, p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_NoPatterns() { - ExtractAppender p = makeAppender(); - - logger.info("hello"); - logger.info("world"); - - assertEquals(strList("hello", "world"), p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_MatchFirstPattern() { - ExtractAppender p = makeAppender("abc[0-9]", "def[0-9]"); - - logger.info("hello abc1"); - logger.info("world xyz2"); - - assertEquals(strList("abc1"), p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_MatchLastPattern() { - ExtractAppender p = makeAppender("abc[0-9]", "def[0-9]"); - - logger.info("hello def1"); - logger.info("world xyz2"); - - assertEquals(strList("def1"), p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_Group1() { - ExtractAppender p = makeAppender("hello (abc)|(xyz)", "def[0-9]"); - - logger.info("hello abc, world!"); - logger.info("world abc"); - - assertEquals(strList("abc"), p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_Group3() { - ExtractAppender p = makeAppender("hello (abc)|(pdq)|(xyz)", "def[0-9]"); - - logger.info("say hello xyz, world!"); - logger.info("world abc"); - - assertEquals(strList("xyz"), p.getExtracted()); - } - - @Test - public void testAppendILoggingEvent_NoGroup() { - ExtractAppender p = makeAppender("hello abc"); - - logger.info("say hello abc, world!"); - logger.info("world abc"); - - assertEquals(strList("hello abc"), p.getExtracted()); - } - - @Test - public void testGetExtracted() { - ExtractAppender p = makeAppender("abc[1-9]"); - - logger.info("hello abc1 world"); - logger.info("world ghi2 world"); // no match - logger.info("hello abc3"); - - List<String> oldlst = p.getExtracted(); - assertEquals(strList("abc1", "abc3"), oldlst); - assertEquals(oldlst, p.getExtracted()); - - logger.info("abc9"); - assertEquals(strList("abc1", "abc3", "abc9"), p.getExtracted()); - } - - @Test - public void testClearExtractions() { - ExtractAppender p = makeAppender("abc[1-9]"); - - logger.info("hello abc1 world"); - logger.info("world ghi2 world"); - logger.info("hello abc3"); - - assertEquals(strList("abc1", "abc3"), p.getExtracted()); - - p.clearExtractions(); - - // list should be empty now - assertEquals(strList(), p.getExtracted()); - - logger.info("hello abc4 world"); - logger.info("world ghi5 world"); - logger.info("hello abc6"); - - // list should only contain the new items - assertEquals(strList("abc4", "abc6"), p.getExtracted()); - } - - @Test - public void testSetPattern() { - ExtractAppender p = makeAppender("abc[1-9]"); - - logger.info("hello abc1 world"); - logger.info("world ghi2 world"); // no match - logger.info("hello abc3"); - - assertEquals(strList("abc1", "abc3"), p.getExtracted()); - - p.setPattern("ghi[0-9]"); - - logger.info("world ghi4 world"); // this should match now - logger.info("hello abc5"); // this should still match - logger.info("hello xyz5"); // no match - - assertEquals(strList("abc1", "abc3", "ghi4", "abc5"), p.getExtracted()); - } - - /** - * Launches threads doing everything in parallel to ensure nothing crashes. - * - * @throws Exception - */ - @Test - public void test_MultiThreaded() throws Exception { - // when to stop - long tend = System.currentTimeMillis() + 250; - - // maximum number of items allowed in the extraction list - int maxItems = 10; - - // this will be set if one of the threads generates an error - AtomicBoolean err = new AtomicBoolean(false); - - // extracted messages go here - this is a finite-length queue since - // we don't know how many messages may actually be logged - LinkedList<String> queue = new LinkedList<String>() { - private static final long serialVersionUID = 1L; - - @Override - public boolean offer(String e) { - if (size() < maxItems) { - return super.offer(e); - } else { - return false; - } - } - }; - - ExtractAppender app = new ExtractAppender(queue, "abc[1-9]"); - addAppender(app); - - // create some threads to add another pattern - addThread(tend, err, xtxt -> { - app.setPattern("def[0-9]"); - }); - - // create some threads to log "abc" messages - addThread(tend, err, xtxt -> { - logger.info("hello abc" + xtxt + "world!"); - }); - - // create some threads to log "def" messages - addThread(tend, err, xtxt -> { - logger.info("hello def" + xtxt + "world!"); - }); - - // create some threads to get extractions - addThread(tend, err, xtxt -> { - app.getExtracted(); - }); - - // create some threads to clear extractions - addThread(tend, err, xtxt -> { - app.clearExtractions(); - - // don't want to clear the list too frequently - // so sleep a bit in between - try { - Thread.sleep(10 + Integer.valueOf(xtxt)); - - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw e; - } - }); - - /* - * Finally ready to start. - */ - - // start all of the threads - for (Thread t : threads) { - t.setDaemon(true); - t.start(); - } - - // wait for each thread to stop - for (Thread t : threads) { - t.join(THREAD_WAIT_MS); - assertFalse(t.isAlive()); - } - - // ensure none of the threads threw an exception - assertFalse(err.get()); - } - - /** - * Adds multiple threads to perform some function repeatedly until the given - * time is reached. - * - * @param tend - * time, in milliseconds, when the test should terminate - * @param haderr - * this will be set to {@code true} if the function throws an - * exception other than an InterruptedException - * @param func - * function to be repeatedly invoked - */ - private void addThread(long tend, AtomicBoolean haderr, VoidFunction func) { - // number of threads of each type to create - int neach = 3; - - for (int x = 0; x < neach; ++x) { - String xtxt = String.valueOf(x); - - threads.add(new Thread() { - @Override - public void run() { - try { - while (System.currentTimeMillis() < tend) { - func.apply(xtxt); - } - - } catch (InterruptedException ex) { - Thread.currentThread().interrupt(); - - } catch (Exception ex) { - haderr.set(true); - } - } - }); - - } - } - - /** - * Makes an appender that recognizes the given set of strings. - * - * @param strings - * regular expressions to be matched - * @return a new appender - */ - private ExtractAppender makeAppender(String... strings) { - ExtractAppender p = new ExtractAppender(strings); - - addAppender(p); - - return p; - } - - /** - * Adds an appender to the logger. - * - * @param app - * appender to be added - */ - private void addAppender(ExtractAppender app) { - app.setContext(logger.getLoggerContext()); - app.start(); - - logger.addAppender(app); - } - - /** - * Converts an array of strings into a list of strings. - * - * @param strings - * array of strings - * @return a list of the strings - */ - private List<String> strList(String... strings) { - return Arrays.asList(strings); - } - - @FunctionalInterface - public interface VoidFunction { - public void apply(String text) throws InterruptedException; - } + appender.setPattern("ghi[0-9]"); + + logger.info("world ghi4 world"); // this should match now + logger.info("hello abc5"); // this should still match + logger.info("hello xyz5"); // no match + + assertEquals(strList("abc1", "abc3", "ghi4", "abc5"), appender.getExtracted()); + } + + /** + * Launches threads doing everything in parallel to ensure nothing crashes. + */ + @Test + public void test_MultiThreaded() throws Exception { + // when to stop + long tend = System.currentTimeMillis() + 250; + + // maximum number of items allowed in the extraction list + int maxItems = 10; + + // this will be set if one of the threads generates an error + AtomicBoolean err = new AtomicBoolean(false); + + // extracted messages go here - this is a finite-length queue since + // we don't know how many messages may actually be logged + LinkedList<String> queue = new LinkedList<String>() { + private static final long serialVersionUID = 1L; + + @Override + public boolean offer(String element) { + if (size() < maxItems) { + return super.offer(element); + } else { + return false; + } + } + }; + + ExtractAppender app = new ExtractAppender(queue, "abc[1-9]"); + addAppender(app); + + // create some threads to add another pattern + addThread(tend, err, xtxt -> { + app.setPattern("def[0-9]"); + }); + + // create some threads to log "abc" messages + addThread(tend, err, xtxt -> { + logger.info("hello abc" + xtxt + "world!"); + }); + + // create some threads to log "def" messages + addThread(tend, err, xtxt -> { + logger.info("hello def" + xtxt + "world!"); + }); + + // create some threads to get extractions + addThread(tend, err, xtxt -> { + app.getExtracted(); + }); + + // create some threads to clear extractions + addThread(tend, err, xtxt -> { + app.clearExtractions(); + + // don't want to clear the list too frequently + // so sleep a bit in between + try { + Thread.sleep(10 + Integer.valueOf(xtxt)); + + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw e; + } + }); + + /* + * Finally ready to start. + */ + + // start all of the threads + for (Thread t : threads) { + t.setDaemon(true); + t.start(); + } + + // wait for each thread to stop + for (Thread t : threads) { + t.join(THREAD_WAIT_MS); + assertFalse(t.isAlive()); + } + + // ensure none of the threads threw an exception + assertFalse(err.get()); + } + + /** + * Adds multiple threads to perform some function repeatedly until the given time is reached. + * + * @param tend time, in milliseconds, when the test should terminate + * @param haderr this will be set to {@code true} if the function throws an exception other than + * an InterruptedException + * @param func function to be repeatedly invoked + */ + private void addThread(long tend, AtomicBoolean haderr, VoidFunction func) { + // number of threads of each type to create + int neach = 3; + + for (int x = 0; x < neach; ++x) { + String xtxt = String.valueOf(x); + + threads.add(new Thread() { + @Override + public void run() { + try { + while (System.currentTimeMillis() < tend) { + func.apply(xtxt); + } + + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + + } catch (Exception ex) { + haderr.set(true); + } + } + }); + + } + } + + /** + * Makes an appender that recognizes the given set of strings. + * + * @param strings regular expressions to be matched + * @return a new appender + */ + private ExtractAppender makeAppender(String... strings) { + ExtractAppender appender = new ExtractAppender(strings); + + addAppender(appender); + + return appender; + } + + /** + * Adds an appender to the logger. + * + * @param app appender to be added + */ + private void addAppender(ExtractAppender app) { + app.setContext(logger.getLoggerContext()); + app.start(); + + logger.addAppender(app); + } + + /** + * Converts an array of strings into a list of strings. + * + * @param strings array of strings + * @return a list of the strings + */ + private List<String> strList(String... strings) { + return Arrays.asList(strings); + } + + @FunctionalInterface + public interface VoidFunction { + public void apply(String text) throws InterruptedException; + } } diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java index 2ed54196..3532002e 100644 --- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java +++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java @@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa; import javax.persistence.EntityManager; /** - * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This - * is useful in try-with-resources statements. + * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This is useful in + * try-with-resources statements. */ public class EntityMgrCloser implements AutoCloseable { - /** - * The wrapped manager. - */ - private final EntityManager em; - - /** - * - * @param em - * manager to be auto-closed - */ - public EntityMgrCloser(EntityManager em) { - this.em = em; - } - - /** - * Gets the EntityManager wrapped within this object. - * - * @return the associated EntityManager - */ - public EntityManager getManager() { - return em; - } - - @Override - public void close() { - em.close(); - } + /** + * The wrapped manager. + */ + private final EntityManager em; + + /** + * Construct an instance with the EntityManager. + * + * @param em manager to be auto-closed + */ + public EntityMgrCloser(EntityManager em) { + this.em = em; + } + + /** + * Gets the EntityManager wrapped within this object. + * + * @return the associated EntityManager + */ + public EntityManager getManager() { + return em; + } + + @Override + public void close() { + em.close(); + } } diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java index 8910c087..b046cc55 100644 --- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java +++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java @@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa; import javax.persistence.EntityManagerFactory; /** - * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close - * functionality. This is useful in try-with-resources statements. + * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close functionality. This is useful in + * try-with-resources statements. */ public class EntityMgrFactoryCloser implements AutoCloseable { - /** - * The wrapped factory. - */ - private final EntityManagerFactory emf; - - /** - * - * @param emf - * manager to be auto-closed - */ - public EntityMgrFactoryCloser(EntityManagerFactory emf) { - this.emf = emf; - } - - /** - * Gets the EntityManagerFactory wrapped within this object. - * - * @return the associated EntityManagerFactory - */ - public EntityManagerFactory getFactory() { - return emf; - } - - @Override - public void close() { - emf.close(); - } + /** + * The wrapped factory. + */ + private final EntityManagerFactory emf; + + /** + * Construct an instance with the given EntityManagerFactory. + * + * @param emf manager to be auto-closed + */ + public EntityMgrFactoryCloser(EntityManagerFactory emf) { + this.emf = emf; + } + + /** + * Gets the EntityManagerFactory wrapped within this object. + * + * @return the associated EntityManagerFactory + */ + public EntityManagerFactory getFactory() { + return emf; + } + + @Override + public void close() { + emf.close(); + } } diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java index ce300741..3552a6fa 100644 --- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java +++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java @@ -23,55 +23,54 @@ package org.onap.policy.common.utils.jpa; import javax.persistence.EntityTransaction; /** - * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed. - * This is useful in try-with-resources statements. + * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed. This is useful in + * try-with-resources statements. */ public class EntityTransCloser implements AutoCloseable { - /** - * Transaction to be rolled back. - */ - private final EntityTransaction trans; + /** + * Transaction to be rolled back. + */ + private final EntityTransaction trans; - /** - * Begins a transaction. - * - * @param et - * transaction to wrap/begin - */ - public EntityTransCloser(EntityTransaction et) { - trans = et; - trans.begin(); - } + /** + * Begins a transaction. + * + * @param et transaction to wrap/begin + */ + public EntityTransCloser(EntityTransaction et) { + trans = et; + trans.begin(); + } - /** - * Gets the wrapped transaction. - * - * @return the transaction - */ - public EntityTransaction getTransation() { - return trans; - } + /** + * Gets the wrapped transaction. + * + * @return the transaction + */ + public EntityTransaction getTransation() { + return trans; + } - /** - * Commits the transaction. - */ - public void commit() { - trans.commit(); - } + /** + * Commits the transaction. + */ + public void commit() { + trans.commit(); + } - /** - * Rolls back the transaction. - */ - public void rollback() { - trans.rollback(); - } + /** + * Rolls back the transaction. + */ + public void rollback() { + trans.rollback(); + } - @Override - public void close() { - if (trans.isActive()) { - trans.rollback(); - } - } + @Override + public void close() { + if (trans.isActive()) { + trans.rollback(); + } + } } diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java index abc8d93f..e791e084 100644 --- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java +++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java @@ -29,84 +29,82 @@ import javax.persistence.EntityManager; import org.junit.Before; import org.junit.Test; -import org.onap.policy.common.utils.jpa.EntityMgrCloser; public class EntityMgrCloserTest { - - private EntityManager mgr; - - - @Before - public void setUp() throws Exception { - mgr = mock(EntityManager.class); - } - - - /** - * Verifies that the constructor does not do anything extra before - * being closed. - */ - @Test - public void testEntityMgrCloser() { - EntityMgrCloser c = new EntityMgrCloser(mgr); - - assertEquals(mgr, c.getManager()); - - // verify not closed yet - verify(mgr, never()).close(); - - c.close(); - - verify(mgr).close(); - } - - @Test - public void testGetManager() { - try(EntityMgrCloser c = new EntityMgrCloser(mgr)) { - assertEquals(mgr, c.getManager()); - } - } - - /** - * Verifies that the manager gets closed when close() is invoked. - */ - @Test - public void testClose() { - EntityMgrCloser c = new EntityMgrCloser(mgr); - - c.close(); - - // should be closed - verify(mgr).close(); - } - - /** - * Ensures that the manager gets closed when "try" block exits normally. - */ - @Test - public void testClose_TryWithoutExcept() { - try(EntityMgrCloser c = new EntityMgrCloser(mgr)) { - - } - - verify(mgr).close(); - } - - /** - * Ensures that the manager gets closed when "try" block throws an - * exception. - */ - @Test - public void testClose_TryWithExcept() { - try { - try(EntityMgrCloser c = new EntityMgrCloser(mgr)) { - throw new Exception("expected exception"); - } - - } catch (Exception e) { - } - - verify(mgr).close(); - } + + private EntityManager mgr; + + + @Before + public void setUp() throws Exception { + mgr = mock(EntityManager.class); + } + + + /** + * Verifies that the constructor does not do anything extra before being closed. + */ + @Test + public void testEntityMgrCloser() { + EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr); + + assertEquals(mgr, entityMgrCloser.getManager()); + + // verify not closed yet + verify(mgr, never()).close(); + + entityMgrCloser.close(); + + verify(mgr).close(); + } + + @Test + public void testGetManager() { + try (EntityMgrCloser c = new EntityMgrCloser(mgr)) { + assertEquals(mgr, c.getManager()); + } + } + + /** + * Verifies that the manager gets closed when close() is invoked. + */ + @Test + public void testClose() { + EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr); + + entityMgrCloser.close(); + + // should be closed + verify(mgr).close(); + } + + /** + * Ensures that the manager gets closed when "try" block exits normally. + */ + @Test + public void testClose_TryWithoutExcept() { + try (EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr)) { + // No need to do anything in the try block + } + + verify(mgr).close(); + } + + /** + * Ensures that the manager gets closed when "try" block throws an exception. + */ + @Test + public void testClose_TryWithExcept() { + try { + try (EntityMgrCloser c = new EntityMgrCloser(mgr)) { + throw new Exception("expected exception"); + } + + } catch (Exception exception) { + // Ignore the exception + } + + verify(mgr).close(); + } } diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java index 60ed27d0..8f2c0159 100644 --- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java +++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java @@ -29,84 +29,82 @@ import javax.persistence.EntityManagerFactory; import org.junit.Before; import org.junit.Test; -import org.onap.policy.common.utils.jpa.EntityMgrFactoryCloser; public class EntityMgrFactoryCloserTest { - - private EntityManagerFactory factory; - - - @Before - public void setUp() throws Exception { - factory = mock(EntityManagerFactory.class); - } - - - /** - * Verifies that the constructor does not do anything extra before - * being closed. - */ - @Test - public void testEntityMgrFactoryCloser() { - EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory); - - assertEquals(factory, c.getFactory()); - - // verify not closed yet - verify(factory, never()).close(); - - c.close(); - - verify(factory).close(); - } - - @Test - public void testgetFactory() { - try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) { - assertEquals(factory, c.getFactory()); - } - } - - /** - * Verifies that the manager gets closed when close() is invoked. - */ - @Test - public void testClose() { - EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory); - - c.close(); - - // should be closed - verify(factory).close(); - } - - /** - * Ensures that the manager gets closed when "try" block exits normally. - */ - @Test - public void testClose_TryWithoutExcept() { - try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) { - - } - - verify(factory).close(); - } - - /** - * Ensures that the manager gets closed when "try" block throws an - * exception. - */ - @Test - public void testClose_TryWithExcept() { - try { - try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) { - throw new Exception("expected exception"); - } - - } catch (Exception e) { - } - - verify(factory).close(); - } + + private EntityManagerFactory factory; + + + @Before + public void setUp() throws Exception { + factory = mock(EntityManagerFactory.class); + } + + + /** + * Verifies that the constructor does not do anything extra before being closed. + */ + @Test + public void testEntityMgrFactoryCloser() { + EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory); + + assertEquals(factory, entityMgrFactoryCloser.getFactory()); + + // verify not closed yet + verify(factory, never()).close(); + + entityMgrFactoryCloser.close(); + + verify(factory).close(); + } + + @Test + public void testgetFactory() { + try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) { + assertEquals(factory, c.getFactory()); + } + } + + /** + * Verifies that the manager gets closed when close() is invoked. + */ + @Test + public void testClose() { + EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory); + + entityMgrFactoryCloser.close(); + + // should be closed + verify(factory).close(); + } + + /** + * Ensures that the manager gets closed when "try" block exits normally. + */ + @Test + public void testClose_TryWithoutExcept() { + try (EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory)) { + // No need to do anything in the try block + } + + verify(factory).close(); + } + + /** + * Ensures that the manager gets closed when "try" block throws an exception. + */ + @Test + public void testClose_TryWithExcept() { + try { + try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) { + throw new Exception("expected exception"); + } + + } catch (Exception exception) { + // Ignore the exception + } + + verify(factory).close(); + } } diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java index e7dcf11c..9a499e49 100644 --- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java +++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java @@ -31,201 +31,202 @@ import javax.persistence.EntityTransaction; import org.junit.Before; import org.junit.Test; -import org.onap.policy.common.utils.jpa.EntityTransCloser; public class EntityTransCloserTest { - - private EntityTransaction trans; - - @Before - public void setUp() throws Exception { - trans = mock(EntityTransaction.class); - - when(trans.isActive()).thenReturn(true); - } - - - - /** - * Verifies that the constructor starts a transaction, but does not do - * anything extra before being closed. - */ - @Test - public void testEntityTransCloser() { - EntityTransCloser t = new EntityTransCloser(trans); - - assertEquals(trans, t.getTransation()); - - // verify that transaction was started - verify(trans).begin(); - - // verify not closed, committed, or rolled back yet - verify(trans, never()).commit(); - verify(trans, never()).rollback(); - - t.close(); - - verify(trans).rollback(); - } - - @Test - public void testGetTransation() { - try(EntityTransCloser t = new EntityTransCloser(trans)) { - assertEquals(trans, t.getTransation()); - } - } - - /** - * Verifies that the transaction is rolled back and the manager is - * closed when and a transaction is active. - */ - @Test - public void testClose_Active() { - EntityTransCloser t = new EntityTransCloser(trans); - - when(trans.isActive()).thenReturn(true); - - t.close(); - - // closed and rolled back, but not committed - verify(trans, never()).commit(); - verify(trans).rollback(); - } - - /** - * Verifies that the manager is closed, but that the transaction is - * <i>not</i> rolled back and when and no transaction is active. - */ - @Test - public void testClose_Inactive() { - EntityTransCloser t = new EntityTransCloser(trans); - - when(trans.isActive()).thenReturn(false); - - t.close(); - - // closed, but not committed or rolled back - verify(trans, never()).commit(); - verify(trans, never()).rollback(); - } - - /** - * Verifies that the manager is closed and the transaction rolled back - * when "try" block exits normally and a transaction is active. - */ - @Test - public void testClose_TryWithoutExcept_Active() { - when(trans.isActive()).thenReturn(true); - - try(EntityTransCloser t = new EntityTransCloser(trans)) { - - } - - // closed and rolled back, but not committed - verify(trans, never()).commit(); - verify(trans).rollback(); - } - - /** - * Verifies that the manager is closed, but that the transaction is - * <i>not</i> rolled back when "try" block exits normally and no - * transaction is active. - */ - @Test - public void testClose_TryWithoutExcept_Inactive() { - when(trans.isActive()).thenReturn(false); - - try(EntityTransCloser t = new EntityTransCloser(trans)) { - - } - - // closed, but not rolled back or committed - verify(trans, never()).commit(); - verify(trans, never()).rollback(); - } - - /** - * Verifies that the manager is closed and the transaction rolled back - * when "try" block throws an exception and a transaction is active. - */ - @Test - public void testClose_TryWithExcept_Active() { - when(trans.isActive()).thenReturn(true); - - try { - try(EntityTransCloser t = new EntityTransCloser(trans)) { - throw new Exception("expected exception"); - } - - } catch (Exception e) { - } - - // closed and rolled back, but not committed - verify(trans, never()).commit(); - verify(trans).rollback(); - } - - /** - * Verifies that the manager is closed, but that the transaction is - * <i>not</i> rolled back when "try" block throws an exception and no - * transaction is active. - */ - @Test - public void testClose_TryWithExcept_Inactive() { - when(trans.isActive()).thenReturn(false); - - try { - try(EntityTransCloser t = new EntityTransCloser(trans)) { - throw new Exception("expected exception"); - } - - } catch (Exception e) { - } - - // closed, but not rolled back or committed - verify(trans, never()).commit(); - verify(trans, never()).rollback(); - } - - /** - * Verifies that commit() only commits, and that the subsequent close() - * does not re-commit. - */ - @Test - public void testCommit() { - EntityTransCloser t = new EntityTransCloser(trans); - - t.commit(); - - // committed, but not closed or rolled back - verify(trans).commit(); - verify(trans, never()).rollback(); - - // closed, but not re-committed - t.close(); - - verify(trans, times(1)).commit(); - } - - /** - * Verifies that rollback() only rolls back, and that the subsequent - * close() does not re-roll back. - */ - @Test - public void testRollback() { - EntityTransCloser t = new EntityTransCloser(trans); - - t.rollback(); - - // rolled back, but not closed or committed - verify(trans, never()).commit(); - verify(trans).rollback(); - - // closed, but not re-rolled back - when(trans.isActive()).thenReturn(false); - t.close(); - - verify(trans, times(1)).rollback(); - } + + private EntityTransaction trans; + + /** + * Set up EntityTransaction mock. + */ + @Before + public void setUp() throws Exception { + trans = mock(EntityTransaction.class); + + when(trans.isActive()).thenReturn(true); + } + + + + /** + * Verifies that the constructor starts a transaction, but does not do anything extra before + * being closed. + */ + @Test + public void testEntityTransCloser() { + EntityTransCloser entityTransCloser = new EntityTransCloser(trans); + + assertEquals(trans, entityTransCloser.getTransation()); + + // verify that transaction was started + verify(trans).begin(); + + // verify not closed, committed, or rolled back yet + verify(trans, never()).commit(); + verify(trans, never()).rollback(); + + entityTransCloser.close(); + + verify(trans).rollback(); + } + + @Test + public void testGetTransation() { + try (EntityTransCloser t = new EntityTransCloser(trans)) { + assertEquals(trans, t.getTransation()); + } + } + + /** + * Verifies that the transaction is rolled back and the manager is closed when and a transaction + * is active. + */ + @Test + public void testClose_Active() { + EntityTransCloser entityTransCloser = new EntityTransCloser(trans); + + when(trans.isActive()).thenReturn(true); + + entityTransCloser.close(); + + // closed and rolled back, but not committed + verify(trans, never()).commit(); + verify(trans).rollback(); + } + + /** + * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back and + * when and no transaction is active. + */ + @Test + public void testClose_Inactive() { + EntityTransCloser entityTransCloser = new EntityTransCloser(trans); + + when(trans.isActive()).thenReturn(false); + + entityTransCloser.close(); + + // closed, but not committed or rolled back + verify(trans, never()).commit(); + verify(trans, never()).rollback(); + } + + /** + * Verifies that the manager is closed and the transaction rolled back when "try" block exits + * normally and a transaction is active. + */ + @Test + public void testClose_TryWithoutExcept_Active() { + when(trans.isActive()).thenReturn(true); + + try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) { + // No need to do anything in the try block + } + + // closed and rolled back, but not committed + verify(trans, never()).commit(); + verify(trans).rollback(); + } + + /** + * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when + * "try" block exits normally and no transaction is active. + */ + @Test + public void testClose_TryWithoutExcept_Inactive() { + when(trans.isActive()).thenReturn(false); + + try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) { + // No need to do anything in the try block + } + + // closed, but not rolled back or committed + verify(trans, never()).commit(); + verify(trans, never()).rollback(); + } + + /** + * Verifies that the manager is closed and the transaction rolled back when "try" block throws + * an exception and a transaction is active. + */ + @Test + public void testClose_TryWithExcept_Active() { + when(trans.isActive()).thenReturn(true); + + try { + try (EntityTransCloser t = new EntityTransCloser(trans)) { + throw new Exception("expected exception"); + } + + } catch (Exception e) { + // Ignore the exception + } + + // closed and rolled back, but not committed + verify(trans, never()).commit(); + verify(trans).rollback(); + } + + /** + * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when + * "try" block throws an exception and no transaction is active. + */ + @Test + public void testClose_TryWithExcept_Inactive() { + when(trans.isActive()).thenReturn(false); + + try { + try (EntityTransCloser t = new EntityTransCloser(trans)) { + throw new Exception("expected exception"); + } + + } catch (Exception e) { + // Ignore the exception + } + + // closed, but not rolled back or committed + verify(trans, never()).commit(); + verify(trans, never()).rollback(); + } + + /** + * Verifies that commit() only commits, and that the subsequent close() does not re-commit. + */ + @Test + public void testCommit() { + EntityTransCloser entityTransCloser = new EntityTransCloser(trans); + + entityTransCloser.commit(); + + // committed, but not closed or rolled back + verify(trans).commit(); + verify(trans, never()).rollback(); + + // closed, but not re-committed + entityTransCloser.close(); + + verify(trans, times(1)).commit(); + } + + /** + * Verifies that rollback() only rolls back, and that the subsequent close() does not re-roll + * back. + */ + @Test + public void testRollback() { + EntityTransCloser entityTransCloser = new EntityTransCloser(trans); + + entityTransCloser.rollback(); + + // rolled back, but not closed or committed + verify(trans, never()).commit(); + verify(trans).rollback(); + + // closed, but not re-rolled back + when(trans.isActive()).thenReturn(false); + entityTransCloser.close(); + + verify(trans, times(1)).rollback(); + } } |