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);
+		}
+	}
+}