diff options
Diffstat (limited to 'framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa')
| -rw-r--r-- | framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/AAATest.java | 469 | ||||
| -rw-r--r-- | framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/StateMachineTest.java | 132 |
2 files changed, 557 insertions, 44 deletions
diff --git a/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/AAATest.java b/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/AAATest.java index 1b581ab1..75a60336 100644 --- a/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/AAATest.java +++ b/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/AAATest.java @@ -15,29 +15,494 @@ */ package org.onosproject.aaa; +import java.nio.ByteBuffer; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.EAP; +import org.onlab.packet.EAPOL; +import org.onlab.packet.EthType; +import org.onlab.packet.Ethernet; +import org.onlab.packet.IPv4; +import org.onlab.packet.IpAddress; +import org.onlab.packet.MacAddress; +import org.onlab.packet.RADIUS; +import org.onlab.packet.RADIUSAttribute; +import org.onlab.packet.UDP; +import org.onlab.packet.VlanId; +import org.onosproject.core.CoreServiceAdapter; +import org.onosproject.net.Annotations; +import org.onosproject.net.Host; +import org.onosproject.net.HostId; +import org.onosproject.net.HostLocation; +import org.onosproject.net.config.Config; +import org.onosproject.net.config.NetworkConfigRegistryAdapter; +import org.onosproject.net.host.HostServiceAdapter; +import org.onosproject.net.packet.DefaultInboundPacket; +import org.onosproject.net.packet.DefaultPacketContext; +import org.onosproject.net.packet.InboundPacket; +import org.onosproject.net.packet.OutboundPacket; +import org.onosproject.net.packet.PacketContext; +import org.onosproject.net.packet.PacketProcessor; +import org.onosproject.net.packet.PacketServiceAdapter; +import org.onosproject.net.provider.ProviderId; + +import com.google.common.base.Charsets; +import com.google.common.collect.ImmutableSet; + +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.onosproject.net.NetTestTools.connectPoint; /** * Set of tests of the ONOS application component. */ public class AAATest { + MacAddress clientMac = MacAddress.valueOf("1a:1a:1a:1a:1a:1a"); + MacAddress serverMac = MacAddress.valueOf("2a:2a:2a:2a:2a:2a"); + + PacketProcessor packetProcessor; private AAA aaa; + List<Ethernet> savedPackets = new LinkedList<>(); + + /** + * Saves the given packet onto the saved packets list. + * + * @param eth packet to save + */ + private void savePacket(Ethernet eth) { + savedPackets.add(eth); + } + + /** + * Keeps a reference to the PacketProcessor and saves the OutboundPackets. + */ + private class MockPacketService extends PacketServiceAdapter { + + @Override + public void addProcessor(PacketProcessor processor, int priority) { + packetProcessor = processor; + } + + @Override + public void emit(OutboundPacket packet) { + try { + Ethernet eth = Ethernet.deserializer().deserialize(packet.data().array(), + 0, packet.data().array().length); + savePacket(eth); + } catch (Exception e) { + fail(e.getMessage()); + } + } + } + + /** + * Mocks the DefaultPacketContext. + */ + private final class TestPacketContext extends DefaultPacketContext { + + private TestPacketContext(long time, InboundPacket inPkt, + OutboundPacket outPkt, boolean block) { + super(time, inPkt, outPkt, block); + } + + @Override + public void send() { + // We don't send anything out. + } + } + + /** + * Mocks a host to allow locating the Radius server. + */ + private static final class MockHost implements Host { + @Override + public HostId id() { + return null; + } + + @Override + public MacAddress mac() { + return null; + } + + @Override + public VlanId vlan() { + return VlanId.vlanId(VlanId.UNTAGGED); + } + + @Override + public Set<IpAddress> ipAddresses() { + return null; + } + + @Override + public HostLocation location() { + return null; + } + + @Override + public Annotations annotations() { + return null; + } + + @Override + public ProviderId providerId() { + return null; + } + } + + /** + * Mocks the Host service. + */ + private static final class MockHostService extends HostServiceAdapter { + @Override + public Set<Host> getHostsByIp(IpAddress ip) { + return ImmutableSet.of(new MockHost()); + } + } + + /** + * Mocks the network config registry. + */ + @SuppressWarnings("unchecked") + private static final class TestNetworkConfigRegistry + extends NetworkConfigRegistryAdapter { + @Override + public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) { + return (C) new AAAConfig(); + } + } + + /** + * Sends an Ethernet packet to the process method of the Packet Processor. + * + * @param reply Ethernet packet + */ + private void sendPacket(Ethernet reply) { + final ByteBuffer byteBuffer = ByteBuffer.wrap(reply.serialize()); + InboundPacket inPacket = new DefaultInboundPacket(connectPoint("1", 1), + reply, + byteBuffer); + + PacketContext context = new TestPacketContext(127L, inPacket, null, false); + packetProcessor.process(context); + } + + /** + * Constructs an Ethernet packet containing a EAPOL_START Payload. + * + * @return Ethernet packet + */ + private Ethernet constructSupplicantStartPacket() { + Ethernet eth = new Ethernet(); + eth.setDestinationMACAddress(clientMac.toBytes()); + eth.setSourceMACAddress(serverMac.toBytes()); + eth.setEtherType(EthType.EtherType.EAPOL.ethType().toShort()); + eth.setVlanID((short) 2); + + EAP eap = new EAP(EAPOL.EAPOL_START, (byte) 1, EAPOL.EAPOL_START, null); + + //eapol header + EAPOL eapol = new EAPOL(); + eapol.setEapolType(EAPOL.EAPOL_START); + eapol.setPacketLength(eap.getLength()); + + //eap part + eapol.setPayload(eap); + + eth.setPayload(eapol); + eth.setPad(true); + return eth; + } + + /** + * Constructs an Ethernet packet containing identification payload. + * + * @return Ethernet packet + */ + private Ethernet constructSupplicantIdentifyPacket(byte type) { + Ethernet eth = new Ethernet(); + eth.setDestinationMACAddress(clientMac.toBytes()); + eth.setSourceMACAddress(serverMac.toBytes()); + eth.setEtherType(EthType.EtherType.EAPOL.ethType().toShort()); + eth.setVlanID((short) 2); + + String username = "user"; + EAP eap = new EAP(EAP.REQUEST, (byte) 1, type, + username.getBytes(Charsets.US_ASCII)); + eap.setIdentifier((byte) 1); + + // eapol header + EAPOL eapol = new EAPOL(); + eapol.setEapolType(EAPOL.EAPOL_PACKET); + eapol.setPacketLength(eap.getLength()); + + // eap part + eapol.setPayload(eap); + + eth.setPayload(eapol); + eth.setPad(true); + return eth; + } + + /** + * Constructs an Ethernet packet containing a RADIUS challenge + * packet. + * + * @param challengeCode code to use in challenge packet + * @param challengeType type to use in challenge packet + * @return Ethernet packet + */ + private Ethernet constructRADIUSCodeAccessChallengePacket(byte challengeCode, byte challengeType) { + Ethernet eth = new Ethernet(); + eth.setDestinationMACAddress(clientMac.toBytes()); + eth.setSourceMACAddress(serverMac.toBytes()); + eth.setEtherType(EthType.EtherType.IPV4.ethType().toShort()); + eth.setVlanID((short) 2); + + IPv4 ipv4 = new IPv4(); + ipv4.setProtocol(IPv4.PROTOCOL_UDP); + ipv4.setSourceAddress(aaa.radiusIpAddress.getHostAddress()); + + String challenge = "1234"; + + EAP eap = new EAP(challengeType, (byte) 1, challengeType, + challenge.getBytes(Charsets.US_ASCII)); + eap.setIdentifier((byte) 1); + + RADIUS radius = new RADIUS(); + radius.setCode(challengeCode); + + radius.setAttribute(RADIUSAttribute.RADIUS_ATTR_STATE, + challenge.getBytes(Charsets.US_ASCII)); + radius.setPayload(eap); + radius.setAttribute(RADIUSAttribute.RADIUS_ATTR_EAP_MESSAGE, + eap.serialize()); + + UDP udp = new UDP(); + udp.setPayload(radius); + ipv4.setPayload(udp); + + eth.setPayload(ipv4); + eth.setPad(true); + return eth; + } + + /** + * Sets up the services required by the AAA application. + */ @Before public void setUp() { - + aaa = new AAA(); + aaa.netCfgService = new TestNetworkConfigRegistry(); + aaa.coreService = new CoreServiceAdapter(); + aaa.packetService = new MockPacketService(); + aaa.hostService = new MockHostService(); + aaa.activate(); } + /** + * Tears down the AAA application. + */ @After public void tearDown() { + aaa.deactivate(); + } + + /** + * Extracts the RADIUS packet from a packet sent by the supplicant. + * + * @param supplicantPacket packet sent by the supplicant + * @return RADIUS packet + * @throws DeserializationException if deserialization of the packet contents + * fails. + */ + private RADIUS checkAndFetchRADIUSPacketFromSupplicant(Ethernet supplicantPacket) + throws DeserializationException { + assertThat(supplicantPacket, notNullValue()); + assertThat(supplicantPacket.getVlanID(), is(VlanId.UNTAGGED)); + assertThat(supplicantPacket.getSourceMAC().toString(), is(aaa.nasMacAddress)); + assertThat(supplicantPacket.getDestinationMAC().toString(), is(aaa.radiusMacAddress)); + + assertThat(supplicantPacket.getPayload(), instanceOf(IPv4.class)); + IPv4 ipv4 = (IPv4) supplicantPacket.getPayload(); + assertThat(ipv4, notNullValue()); + assertThat(IpAddress.valueOf(ipv4.getSourceAddress()).toString(), + is(aaa.nasIpAddress.getHostAddress())); + assertThat(IpAddress.valueOf(ipv4.getDestinationAddress()).toString(), + is(aaa.radiusIpAddress.getHostAddress())); + + assertThat(ipv4.getPayload(), instanceOf(UDP.class)); + UDP udp = (UDP) ipv4.getPayload(); + assertThat(udp, notNullValue()); + + assertThat(udp.getPayload(), instanceOf(Data.class)); + Data data = (Data) udp.getPayload(); + RADIUS radius = RADIUS.deserializer() + .deserialize(data.getData(), 0, data.getData().length); + assertThat(radius, notNullValue()); + return radius; } + /** + * Checks the contents of a RADIUS packet being sent to the RADIUS server. + * + * @param radiusPacket packet to check + * @param code expected code + */ + private void checkRadiusPacket(Ethernet radiusPacket, byte code) { + assertThat(radiusPacket.getVlanID(), is((short) 2)); + + // TODO: These address values seem wrong, but are produced by the current AAA implementation + assertThat(radiusPacket.getSourceMAC(), is(MacAddress.valueOf(1L))); + assertThat(radiusPacket.getDestinationMAC(), is(serverMac)); + + assertThat(radiusPacket.getPayload(), instanceOf(EAPOL.class)); + EAPOL eapol = (EAPOL) radiusPacket.getPayload(); + assertThat(eapol, notNullValue()); + + assertThat(eapol.getEapolType(), is(EAPOL.EAPOL_PACKET)); + assertThat(eapol.getPayload(), instanceOf(EAP.class)); + EAP eap = (EAP) eapol.getPayload(); + assertThat(eap, notNullValue()); + assertThat(eap.getCode(), is(code)); + } + + /** + * Fetches the sent packet at the given index. The requested packet + * must be the last packet on the list. + * + * @param index index into sent packets array + * @return packet + */ + private Ethernet fetchPacket(int index) { + assertThat(savedPackets.size(), is(index + 1)); + Ethernet eth = savedPackets.get(index); + assertThat(eth, notNullValue()); + return eth; + } + + /** + * Tests the authentication path through the AAA application. + * + * @throws DeserializationException if packed deserialization fails. + */ @Test - public void basics() { + public void testAuthentication() throws DeserializationException { + + // Our session id will be the device ID ("of:1") with the port ("1") concatenated + String sessionId = "of:11"; + + // (1) Supplicant start up + + Ethernet startPacket = constructSupplicantStartPacket(); + sendPacket(startPacket); + + Ethernet responsePacket = fetchPacket(0); + checkRadiusPacket(responsePacket, EAP.ATTR_IDENTITY); + + // (2) Supplicant identify + + Ethernet identifyPacket = constructSupplicantIdentifyPacket(EAP.ATTR_IDENTITY); + sendPacket(identifyPacket); + Ethernet radiusIdentifyPacket = fetchPacket(1); + + RADIUS radiusAccessRequest = checkAndFetchRADIUSPacketFromSupplicant(radiusIdentifyPacket); + assertThat(radiusAccessRequest, notNullValue()); + assertThat(radiusAccessRequest.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST)); + assertThat(new String(radiusAccessRequest.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()), + is("user")); + + IpAddress nasIp = + IpAddress.valueOf(IpAddress.Version.INET, + radiusAccessRequest.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP) + .getValue()); + assertThat(nasIp.toString(), is(aaa.nasIpAddress.getHostAddress())); + + // State machine should have been created by now + + StateMachine stateMachine = + StateMachine.lookupStateMachineBySessionId(sessionId); + assertThat(stateMachine, notNullValue()); + assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING)); + + // (3) RADIUS MD5 challenge + + Ethernet radiusCodeAccessChallengePacket = + constructRADIUSCodeAccessChallengePacket(RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5); + sendPacket(radiusCodeAccessChallengePacket); + + Ethernet radiusChallengeMD5Packet = fetchPacket(2); + checkRadiusPacket(radiusChallengeMD5Packet, EAP.ATTR_MD5); + + // (4) Supplicant MD5 response + + Ethernet md5RadiusPacket = constructSupplicantIdentifyPacket(EAP.ATTR_MD5); + sendPacket(md5RadiusPacket); + Ethernet supplicantMD5ResponsePacket = fetchPacket(3); + RADIUS responseMd5RadiusPacket = checkAndFetchRADIUSPacketFromSupplicant(supplicantMD5ResponsePacket); + assertThat(responseMd5RadiusPacket.getIdentifier(), is((byte) 1)); + assertThat(responseMd5RadiusPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST)); + + // State machine should be in pending state + + assertThat(stateMachine, notNullValue()); + assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING)); + + // (5) RADIUS TLS Challenge + + Ethernet radiusCodeAccessChallengeTLSPacket = + constructRADIUSCodeAccessChallengePacket(RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_TLS); + sendPacket(radiusCodeAccessChallengeTLSPacket); + + Ethernet radiusChallengeTLSPacket = fetchPacket(4); + checkRadiusPacket(radiusChallengeTLSPacket, EAP.ATTR_TLS); + + // (6) Supplicant TLS response + + Ethernet tlsRadiusPacket = constructSupplicantIdentifyPacket(EAP.ATTR_TLS); + sendPacket(tlsRadiusPacket); + Ethernet supplicantTLSResponsePacket = fetchPacket(5); + RADIUS responseTLSRadiusPacket = checkAndFetchRADIUSPacketFromSupplicant(supplicantTLSResponsePacket); + assertThat(responseTLSRadiusPacket.getIdentifier(), is((byte) 0)); + assertThat(responseTLSRadiusPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST)); + + // (7) RADIUS Success + + Ethernet successPacket = + constructRADIUSCodeAccessChallengePacket(RADIUS.RADIUS_CODE_ACCESS_ACCEPT, EAP.SUCCESS); + sendPacket(successPacket); + Ethernet supplicantSuccessPacket = fetchPacket(6); + + checkRadiusPacket(supplicantSuccessPacket, EAP.SUCCESS); + + // State machine should be in authorized state + + assertThat(stateMachine, notNullValue()); + assertThat(stateMachine.state(), is(StateMachine.STATE_AUTHORIZED)); } + /** + * Tests the default configuration. + */ + @Test + public void testConfig() { + assertThat(aaa.nasIpAddress.getHostAddress(), is(AAAConfig.DEFAULT_NAS_IP)); + assertThat(aaa.nasMacAddress, is(AAAConfig.DEFAULT_NAS_MAC)); + assertThat(aaa.radiusIpAddress.getHostAddress(), is(AAAConfig.DEFAULT_RADIUS_IP)); + assertThat(aaa.radiusMacAddress, is(AAAConfig.DEFAULT_RADIUS_MAC)); + } } diff --git a/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/StateMachineTest.java b/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/StateMachineTest.java index 2fe44ab9..04837e85 100644 --- a/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/StateMachineTest.java +++ b/framework/src/onos/apps/aaa/src/test/java/org/onosproject/aaa/StateMachineTest.java @@ -21,6 +21,7 @@ import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import static org.junit.Assert.*; public class StateMachineTest { @@ -30,6 +31,7 @@ public class StateMachineTest { public void setUp() { System.out.println("Set Up."); StateMachine.bitSet.clear(); + StateMachine.initializeMaps(); stateMachine = new StateMachine("session0", null); } @@ -37,6 +39,7 @@ public class StateMachineTest { public void tearDown() { System.out.println("Tear Down."); StateMachine.bitSet.clear(); + StateMachine.destroyMaps(); stateMachine = null; } @@ -46,19 +49,19 @@ public class StateMachineTest { */ public void basic() throws StateMachineException { System.out.println("======= BASIC =======."); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); } @Test @@ -68,19 +71,19 @@ public class StateMachineTest { public void testIdleState() throws StateMachineException { System.out.println("======= IDLE STATE TEST =======."); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); } @Test @@ -92,19 +95,19 @@ public class StateMachineTest { stateMachine.start(); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_STARTED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_STARTED); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); } @Test @@ -118,19 +121,19 @@ public class StateMachineTest { stateMachine.requestAccess(); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); } @Test @@ -144,19 +147,19 @@ public class StateMachineTest { stateMachine.requestAccess(); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_PENDING); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_PENDING); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); } @Test @@ -170,19 +173,19 @@ public class StateMachineTest { stateMachine.authorizeAccess(); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_AUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_AUTHORIZED); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); } @Test @@ -196,27 +199,27 @@ public class StateMachineTest { stateMachine.denyAccess(); stateMachine.start(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); stateMachine.requestAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); stateMachine.authorizeAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); stateMachine.denyAccess(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_UNAUTHORIZED); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_UNAUTHORIZED); stateMachine.logoff(); - Assert.assertEquals(stateMachine.getState(), StateMachine.STATE_IDLE); + Assert.assertEquals(stateMachine.state(), StateMachine.STATE_IDLE); } @Test public void testIdentifierAvailability() throws StateMachineException { System.out.println("======= IDENTIFIER TEST =======."); - byte identifier = stateMachine.getIdentifier(); - System.out.println("State: " + stateMachine.getState()); + byte identifier = stateMachine.identifier(); + System.out.println("State: " + stateMachine.state()); System.out.println("Identifier: " + Byte.toUnsignedInt(identifier)); Assert.assertEquals(-1, identifier); stateMachine.start(); @@ -230,7 +233,7 @@ public class StateMachineTest { for (int i = 1; i <= 255; i++) { StateMachine sm = new StateMachine("session" + i, null); sm.start(); - byte id = sm.getIdentifier(); + byte id = sm.identifier(); Assert.assertEquals(i, Byte.toUnsignedInt(id)); if (i == 3) { sm3 = sm; @@ -244,27 +247,72 @@ public class StateMachineTest { //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(); - sm247 = null; + Assert.assertNotNull(sm3); sm3.requestAccess(); sm3.authorizeAccess(); sm3.logoff(); - sm3 = null; StateMachine otherSM3 = new StateMachine("session3b", null); otherSM3.start(); otherSM3.requestAccess(); - byte id3 = otherSM3.getIdentifier(); + byte id3 = otherSM3.identifier(); Assert.assertEquals(3, Byte.toUnsignedInt(id3)); StateMachine otherSM247 = new StateMachine("session247b", null); otherSM247.start(); otherSM247.requestAccess(); - byte id247 = otherSM247.getIdentifier(); + 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, null); + StateMachine stateMachine2 = new StateMachine(sessionId2, null); + + 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, null); + stateMachine1.start(); + StateMachine stateMachine2 = new StateMachine(sessionId2, null); + stateMachine2.start(); + + assertEquals(stateMachine1, + StateMachine.lookupStateMachineById(stateMachine1.identifier())); + assertEquals(stateMachine2, + StateMachine.lookupStateMachineById(stateMachine2.identifier())); } } |