diff options
author | Jim Hahn <jrh3@att.com> | 2018-02-13 14:16:47 -0500 |
---|---|---|
committer | Jim Hahn <jrh3@att.com> | 2018-02-13 14:26:22 -0500 |
commit | e871132b09476d7772fb8dbc597fb82248b89f6b (patch) | |
tree | c78deaa56f3c6af84b8a7362c6066e5f6ce18f10 /integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java | |
parent | 86664073b5a778c56e831d64b3a1883818af0ffe (diff) |
Speed up integrity-audit tests
Added additional DbDAO constructors to facilitate JUnit testing.
Added DbDAO destroy() method to close the EntityManagerFactory.
Pulled out common code into IntegrityAuditTestBase and subclassed
the tests from there.
Added hooks to IntegrityAudit so that the AuditThread timers could
be set to smaller values so that all of the junit tests could be
run in much less time.
Added similar hooks to DbAudit.
Modified integrity-audit tests to use new utility classes to auto-close
JPA managers.
Modified integrity-audit tests to use new utility class to scan logger
items without the need to scan the actual log file.
Added code to new test superclass to truncate the four ONAP logs.
Modified hooks in IntegrityAuditEntity to adjust serialization
so that dates are not serialized/de-serialized when used in junit
tests.
Deleted TestingUtils.
Added a test for invalid nodeType property.
Fixed issue wherein AuditThread doesn't stop when interrupted.
Change-Id: I5101995b6b68655b2810777bc4d2ec80c7cbc363
Issue-ID: POLICY-582
Signed-off-by: Jim Hahn <jrh3@att.com>
Diffstat (limited to 'integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java')
-rw-r--r-- | integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java | 260 |
1 files changed, 260 insertions, 0 deletions
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java new file mode 100644 index 00000000..b627977b --- /dev/null +++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java @@ -0,0 +1,260 @@ +/*- + * ============LICENSE_START======================================================= + * Integrity Audit + * ================================================================================ + * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.ia; + +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicLong; + +//import org.apache.commons.logging.Log; +//import org.apache.commons.logging.LogFactory; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.common.utils.test.log.logback.ExtractAppender; + +/* + * All JUnits are designed to run in the local development environment + * where they have write privileges and can execute time-sensitive + * tasks. + */ +public class AuditPeriodTest extends IntegrityAuditTestBase { + + private static Logger logger = FlexLogger.getLogger(AuditPeriodTest.class); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + AuditPeriodTest.class.getSimpleName()); + } + + @AfterClass + public static void tearDownAfterClass() { + IntegrityAuditTestBase.tearDownAfterClass(); + } + + @Before + public void setUp() { + logger.info("setUp: Entering"); + + super.setUp(); + + logger.info("setUp: Exiting"); + + } + + @After + public void tearDown() { + logger.info("tearDown: Entering"); + + super.tearDown(); + + logger.info("tearDown: Exiting"); + } + + /* + * Verifies (via log parsing) that when a negative audit period is + * specified, the audit is suppressed. + */ + @Test + public void testNegativeAuditPeriod() throws Exception { + + logger.info("testNegativeAuditPeriod: Entering"); + + properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "-1"); + + ExtractAppender logA = watch(debugLogger, "Suppressing integrity audit, integrityAuditPeriodSeconds=([^,]*)"); + + MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU); + + /* + * Sleep long enough to allow + * + * 1) audit to immediately terminate. + */ + waitThread(integrityAudit); + + verifyItemsInLog(logA, "-1"); + + logger.info("testNegativeAuditPeriod: Exiting"); + + } + + /* + * Verifies (via log parsing) that when an audit period of zero is + * specified, the audit runs continuously, generating a number of sleep/wake + * sequences in a short period of time (e.g. 100ms). + */ + @Test + public void testZeroAuditPeriod() throws Exception { + + logger.info("testZeroAuditPeriod: Entering"); + + properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "0"); + + ExtractAppender logA = watch(debugLogger, "[Aa]waking from (0ms) sleep"); + + MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU); + + /* + * Wait for + * + * 1) audit to generate a bunch of sleep wake sequences. + */ + String[] awakings = new String[10]; + for (int x = 0; x < awakings.length; ++x) { + awakings[x] = "0ms"; + runAudit(integrityAudit); + } + + // run a couple more audits + runAudit(integrityAudit); + runAudit(integrityAudit); + + /* + * We should get at least 10 sleep/wake sequences. + */ + + verifyItemsInLog(logA, awakings); + + logger.info("testZeroAuditPeriod: Exiting"); + + } + + /** + * Verifies that when different audit periods are specified, there is an + * appropriate interval between the audits. + */ + @Test + public void testLongAuditPeriod() throws Exception { + + logger.info("testLongAuditPeriod: Entering"); + + testAuditPeriod(100); + testAuditPeriod(200); + + logger.info("testLongAuditPeriod: Exiting"); + } + + /** + * Verifies that audits actually take as long as expected, even with + * multiple auditors running simultaneously. + * + * @param periodms + * audit period, in milliseconds + * @throws Exception + * @throws InterruptedException + */ + private void testAuditPeriod(long periodms) throws Exception, InterruptedException { + + properties.put(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS, String.valueOf(periodms)); + + /* + * Start several auditors. + */ + MyIntegrityAudit[] ia = new MyIntegrityAudit[3]; + for (int x = 0; x < ia.length; ++x) { + ia[x] = makeAuditor("pdp" + x, A_SEQ_PU); + } + + /* + * Run an audit on all of them. + */ + runAudit(ia); + + /* + * Now run again and ensure it waited long enough between runs. + */ + long tmin = minAuditTime(ia); + assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS); + + /* + * Now run again and ensure it waited long enough between runs. + */ + tmin = minAuditTime(ia); + assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS); + } + + /** + * Runs simultaneous audits on several auditors. + * + * @param auditors + * @return the minimum time, in milliseconds, elapsed for any given auditor + * @throws InterruptedException + */ + private long minAuditTime(MyIntegrityAudit... auditors) throws InterruptedException { + List<Thread> threads = new ArrayList<>(auditors.length); + AtomicLong tfirst = new AtomicLong(Long.MAX_VALUE); + long tbeg = System.currentTimeMillis(); + + // create the threads + for (MyIntegrityAudit p : auditors) { + Thread t = new Thread() { + + @Override + public void run() { + try { + runAudit(p); + setMinTime(tfirst); + + } catch (InterruptedException e) { + ; + } + } + }; + + t.setDaemon(true); + threads.add(t); + } + + // start the threads + for (Thread t : threads) { + t.start(); + } + + // wait for them to complete + for (Thread t : threads) { + t.join(); + } + + return (tfirst.get() - tbeg); + } + + /** + * Sets a value to the minimum between the current value and the current + * time. + * + * @param tmin + * current minimum value/value to be set + */ + private static void setMinTime(AtomicLong tmin) { + long tcur = System.currentTimeMillis(); + long t; + while ((t = tmin.get()) > tcur) { + tmin.compareAndSet(t, tcur); + } + } +} |