pom modications to appify aaa
renaming package
diff --git a/src/test/java/org/opencord/aaa/StateMachineTest.java b/src/test/java/org/opencord/aaa/StateMachineTest.java
new file mode 100644
index 0000000..6626537
--- /dev/null
+++ b/src/test/java/org/opencord/aaa/StateMachineTest.java
@@ -0,0 +1,320 @@
+/*
+ *
+ * Copyright 2015 AT&T Foundry
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package org.opencord.aaa;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+
+public class StateMachineTest {
+ StateMachine stateMachine = null;
+
+ @Before
+ public void setUp() {
+ System.out.println("Set Up.");
+ StateMachine.bitSet.clear();
+ StateMachine.initializeMaps();
+ stateMachine = new StateMachine("session0");
+ }
+
+ @After
+ public void tearDown() {
+ System.out.println("Tear Down.");
+ StateMachine.bitSet.clear();
+ StateMachine.destroyMaps();
+ stateMachine = null;
+ }
+
+ @Test
+ /**
+ * Test all the basic inputs from state to state: IDLE -> STARTED -> PENDING -> AUTHORIZED -> IDLE
+ */
+ public void basic() throws StateMachineException {
+ System.out.println("======= BASIC =======.");
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED);
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+ }
+
+ @Test
+ /**
+ * Test all inputs from an IDLE state (starting with the ones that are not impacting the current state)
+ */
+ public void testIdleState() throws StateMachineException {
+ System.out.println("======= IDLE STATE TEST =======.");
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+ }
+
+ @Test
+ /**
+ * Test all inputs from an STARTED state (starting with the ones that are not impacting the current state)
+ */
+ public void testStartedState() throws StateMachineException {
+ System.out.println("======= STARTED STATE TEST =======.");
+ stateMachine.start();
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+ }
+
+ @Test
+ /**
+ * Test all inputs from a PENDING state (starting with the ones that are not impacting the current state).
+ * The next valid state for this test is AUTHORIZED
+ */
+ public void testPendingStateToAuthorized() throws StateMachineException {
+ System.out.println("======= PENDING STATE TEST (AUTHORIZED) =======.");
+ stateMachine.start();
+ stateMachine.requestAccess();
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED);
+ }
+
+ @Test
+ /**
+ * Test all inputs from an PENDING state (starting with the ones that are not impacting the current state).
+ * The next valid state for this test is UNAUTHORIZED
+ */
+ public void testPendingStateToUnauthorized() throws StateMachineException {
+ System.out.println("======= PENDING STATE TEST (DENIED) =======.");
+ stateMachine.start();
+ stateMachine.requestAccess();
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+ }
+
+ @Test
+ /**
+ * Test all inputs from an AUTHORIZED state (starting with the ones that are not impacting the current state).
+ */
+ public void testAuthorizedState() throws StateMachineException {
+ System.out.println("======= AUTHORIZED STATE TEST =======.");
+ stateMachine.start();
+ stateMachine.requestAccess();
+ stateMachine.authorizeAccess();
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_STARTED);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_PENDING);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED);
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+ }
+
+ @Test
+ /**
+ * Test all inputs from an UNAUTHORIZED state (starting with the ones that are not impacting the current state).
+ */
+ public void testUnauthorizedState() throws StateMachineException {
+ System.out.println("======= UNAUTHORIZED STATE TEST =======.");
+ stateMachine.start();
+ stateMachine.requestAccess();
+ stateMachine.denyAccess();
+
+ stateMachine.start();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+
+ stateMachine.requestAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+
+ stateMachine.authorizeAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+
+ stateMachine.denyAccess();
+ assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED);
+
+ stateMachine.logoff();
+ assertEquals(stateMachine.state(), StateMachine.STATE_IDLE);
+ }
+
+
+ @Test
+ public void testIdentifierAvailability() throws StateMachineException {
+ System.out.println("======= IDENTIFIER TEST =======.");
+ byte identifier = stateMachine.identifier();
+ System.out.println("State: " + stateMachine.state());
+ System.out.println("Identifier: " + Byte.toUnsignedInt(identifier));
+ Assert.assertEquals(-1, identifier);
+ stateMachine.start();
+
+
+ StateMachine sm247 = null;
+ StateMachine sm3 = null;
+
+
+ //create 255 others state machines
+ for (int i = 1; i <= 255; i++) {
+ StateMachine sm = new StateMachine("session" + i);
+ sm.start();
+ byte id = sm.identifier();
+ Assert.assertEquals(i, Byte.toUnsignedInt(id));
+ if (i == 3) {
+ sm3 = sm;
+ System.out.println("SM3: " + sm3.toString());
+ }
+ if (i == 247) {
+ sm247 = sm;
+ System.out.println("SM247: " + sm247.toString());
+ }
+ }
+
+ //simulate the state machine for a specific session and logoff so we can free up a spot for an identifier
+ //let's choose identifier 247 then we free up 3
+ Assert.assertNotNull(sm247);
+ sm247.requestAccess();
+ sm247.authorizeAccess();
+ sm247.logoff();
+
+ Assert.assertNotNull(sm3);
+ sm3.requestAccess();
+ sm3.authorizeAccess();
+ sm3.logoff();
+
+ StateMachine otherSM3 = new StateMachine("session3b");
+ otherSM3.start();
+ otherSM3.requestAccess();
+ byte id3 = otherSM3.identifier();
+ Assert.assertEquals(3, Byte.toUnsignedInt(id3));
+
+ StateMachine otherSM247 = new StateMachine("session247b");
+ otherSM247.start();
+ otherSM247.requestAccess();
+ byte id247 = otherSM247.identifier();
+ Assert.assertEquals(247, Byte.toUnsignedInt(id247));
+ }
+
+ @Test
+ public void testSessionIdLookups() {
+ String sessionId1 = "session1";
+ String sessionId2 = "session2";
+ String sessionId3 = "session3";
+
+ StateMachine machine1ShouldBeNull =
+ StateMachine.lookupStateMachineBySessionId(sessionId1);
+ assertNull(machine1ShouldBeNull);
+ StateMachine machine2ShouldBeNull =
+ StateMachine.lookupStateMachineBySessionId(sessionId2);
+ assertNull(machine2ShouldBeNull);
+
+ StateMachine stateMachine1 = new StateMachine(sessionId1);
+ StateMachine stateMachine2 = new StateMachine(sessionId2);
+
+ assertEquals(stateMachine1,
+ StateMachine.lookupStateMachineBySessionId(sessionId1));
+ assertEquals(stateMachine2,
+ StateMachine.lookupStateMachineBySessionId(sessionId2));
+ assertNull(StateMachine.lookupStateMachineBySessionId(sessionId3));
+ }
+
+ @Test
+ public void testIdentifierLookups() throws StateMachineException {
+ String sessionId1 = "session1";
+ String sessionId2 = "session2";
+
+ StateMachine machine1ShouldBeNull =
+ StateMachine.lookupStateMachineById((byte) 1);
+ assertNull(machine1ShouldBeNull);
+ StateMachine machine2ShouldBeNull =
+ StateMachine.lookupStateMachineById((byte) 2);
+ assertNull(machine2ShouldBeNull);
+
+ StateMachine stateMachine1 = new StateMachine(sessionId1);
+ stateMachine1.start();
+ StateMachine stateMachine2 = new StateMachine(sessionId2);
+ stateMachine2.start();
+
+ assertEquals(stateMachine1,
+ StateMachine.lookupStateMachineById(stateMachine1.identifier()));
+ assertEquals(stateMachine2,
+ StateMachine.lookupStateMachineById(stateMachine2.identifier()));
+ }
+}