[SEBA-593] Splitting aaa app in implementation and api bundles
Change-Id: Ib81650be0695258bdd1f4cd6131f2206760e0da6
diff --git a/app/src/test/java/org/opencord/aaa/impl/StateMachineTest.java b/app/src/test/java/org/opencord/aaa/impl/StateMachineTest.java
new file mode 100644
index 0000000..4053ff9
--- /dev/null
+++ b/app/src/test/java/org/opencord/aaa/impl/StateMachineTest.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * 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.impl;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.MacAddress;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+public class StateMachineTest {
+ StateMachine stateMachine = null;
+
+ @Before
+ public void setUp() {
+ System.out.println("Set Up.");
+ StateMachine.initializeMaps();
+ StateMachine.setDelegate(e -> { });
+ stateMachine = new StateMachine("session0");
+ }
+
+ @After
+ public void tearDown() {
+ System.out.println("Tear Down.");
+ 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_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
+ 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()));
+ }
+
+ @Test
+ /**
+ * Test state machine deletes
+ */
+ public void testStateMachineReset() throws StateMachineException {
+
+ int count = 256;
+
+ //StateMachine.initializeMaps();
+ StateMachine.lookupStateMachineById((byte) 1);
+
+ // Instantiate a bunch of state machines
+ for (int i = 0; i < count; i += 1) {
+ String mac = String.format("00:00:00:00:00:%02x", i);
+ StateMachine sm = new StateMachine(mac);
+ sm.start();
+ sm.setSupplicantAddress(MacAddress.valueOf(mac));
+ }
+
+ // Verify all state machines with a "even" MAC exist
+ for (int i = 0; i < count; i += 2) {
+ String mac = String.format("00:00:00:00:00:%02x", i);
+ assertNotNull(StateMachine.lookupStateMachineBySessionId(mac));
+ }
+
+ // Delete all state machines with a "even" MAC
+ for (int i = 0; i < count; i += 2) {
+ String mac = String.format("00:00:00:00:00:%02x", i);
+ StateMachine.deleteByMac(MacAddress.valueOf(mac));
+ }
+
+ // Verify all the delete state machines no long exist
+ for (int i = 0; i < count; i += 2) {
+ String mac = String.format("00:00:00:00:00:%02x", i);
+ assertNull(StateMachine.lookupStateMachineBySessionId(mac));
+ }
+ }
+}