Merge "Add new version of aaa"

6 files changed, 770 insertions, 0 deletions

diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationBuilderTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationBuilderTest.java
new file mode 100644
index 00000000..2f69fe5b
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationBuilderTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import org.junit.Test;
+import org.opendaylight.aaa.api.Authentication;
+import org.opendaylight.aaa.api.Claim;
+
+public class AuthenticationBuilderTest {
+    private Set<String> roles = new LinkedHashSet<>(Arrays.asList("role1", "role2"));
+    private Claim validClaim = new ClaimBuilder().setDomain("aName").setUserId("1")
+            .setClientId("2222").setUser("bob").addRole("foo").addRoles(roles).build();
+
+    @Test
+    public void testBuildWithExpiration() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertEquals(1, a1.expiration());
+        assertEquals("aName", a1.domain());
+        assertEquals("1", a1.userId());
+        assertEquals("2222", a1.clientId());
+        assertEquals("bob", a1.user());
+        assertTrue(a1.roles().contains("foo"));
+        assertTrue(a1.roles().containsAll(roles));
+        assertEquals(3, a1.roles().size());
+        Authentication a2 = new AuthenticationBuilder(a1).build();
+        assertNotEquals(a1, a2);
+        Authentication a3 = new AuthenticationBuilder(a1).setExpiration(1).build();
+        assertEquals(a1, a3);
+    }
+
+    @Test
+    public void testBuildWithoutExpiration() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).build();
+        assertEquals(0, a1.expiration());
+        assertEquals("aName", a1.domain());
+        assertEquals("1", a1.userId());
+        assertEquals("2222", a1.clientId());
+        assertEquals("bob", a1.user());
+        assertTrue(a1.roles().contains("foo"));
+        assertTrue(a1.roles().containsAll(roles));
+        assertEquals(3, a1.roles().size());
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithNegativeExpiration() {
+        AuthenticationBuilder a1 = new AuthenticationBuilder(validClaim).setExpiration(-1);
+        a1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithNullClaim() {
+        AuthenticationBuilder a1 = new AuthenticationBuilder(null);
+        a1.build();
+    }
+
+    @Test
+    public void testToString() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertEquals(
+                "expiration:1,clientId:2222,userId:1,userName:bob,domain:aName,roles:[foo, role1, role2]",
+                a1.toString());
+    }
+
+    @Test
+    public void testEquals() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertTrue(a1.equals(a1));
+        Authentication a2 = new AuthenticationBuilder(a1).setExpiration(1).build();
+        assertTrue(a1.equals(a2));
+        assertTrue(a2.equals(a1));
+        Authentication a3 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertTrue(a1.equals(a3));
+        assertTrue(a3.equals(a2));
+        assertTrue(a1.equals(a2));
+    }
+
+    @Test
+    public void testNotEquals() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertFalse(a1.equals(null));
+        assertFalse(a1.equals("wrong object"));
+        Authentication a2 = new AuthenticationBuilder(a1).build();
+        assertFalse(a1.equals(a2));
+        assertFalse(a2.equals(a1));
+        Authentication a3 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertFalse(a1.equals(a2));
+        assertTrue(a1.equals(a3));
+        assertFalse(a2.equals(a3));
+        Authentication a4 = new AuthenticationBuilder(validClaim).setExpiration(9).build();
+        assertFalse(a1.equals(a4));
+        assertFalse(a4.equals(a1));
+        Authentication a5 = new AuthenticationBuilder(a1).setExpiration(9).build();
+        assertFalse(a1.equals(a5));
+        assertFalse(a5.equals(a1));
+    }
+
+    @Test
+    public void testHashCode() {
+        Authentication a1 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertEquals(a1.hashCode(), a1.hashCode());
+        Authentication a2 = new AuthenticationBuilder(a1).setExpiration(1).build();
+        assertTrue(a1.equals(a2));
+        assertEquals(a1.hashCode(), a2.hashCode());
+        Authentication a3 = new AuthenticationBuilder(validClaim).setExpiration(1).build();
+        assertTrue(a1.equals(a3));
+        assertEquals(a1.hashCode(), a3.hashCode());
+        assertEquals(a2.hashCode(), a3.hashCode());
+        Authentication a4 = new AuthenticationBuilder(a1).setExpiration(9).build();
+        assertFalse(a1.equals(a4));
+        assertNotEquals(a1.hashCode(), a4.hashCode());
+        Authentication a5 = new AuthenticationBuilder(a1).build();
+        assertFalse(a1.equals(a5));
+        assertNotEquals(a1.hashCode(), a5.hashCode());
+    }
+}
diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationManagerTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationManagerTest.java
new file mode 100644
index 00000000..540df287
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/AuthenticationManagerTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2014, 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.junit.Test;
+import org.opendaylight.aaa.api.Authentication;
+import org.opendaylight.aaa.api.AuthenticationService;
+import org.osgi.service.cm.ConfigurationException;
+
+public class AuthenticationManagerTest {
+    @Test
+    public void testAuthenticationCrudSameThread() {
+        Authentication auth = new AuthenticationBuilder(new ClaimBuilder().setUser("Bob")
+                .setUserId("1234").addRole("admin").addRole("guest").build()).build();
+        AuthenticationService as = AuthenticationManager.instance();
+
+        assertNotNull(as);
+
+        as.set(auth);
+        assertEquals(auth, as.get());
+
+        as.clear();
+        assertNull(as.get());
+    }
+
+    @Test
+    public void testAuthenticationCrudSpawnedThread() throws InterruptedException,
+            ExecutionException {
+        AuthenticationService as = AuthenticationManager.instance();
+        Authentication auth = new AuthenticationBuilder(new ClaimBuilder().setUser("Bob")
+                .setUserId("1234").addRole("admin").addRole("guest").build()).build();
+
+        as.set(auth);
+        Future<Authentication> f = Executors.newSingleThreadExecutor().submit(new Worker());
+        assertEquals(auth, f.get());
+
+        as.clear();
+        f = Executors.newSingleThreadExecutor().submit(new Worker());
+        assertNull(f.get());
+    }
+
+    @Test
+    public void testAuthenticationCrudSpawnedThreadPool() throws InterruptedException,
+            ExecutionException {
+        AuthenticationService as = AuthenticationManager.instance();
+        Authentication auth = new AuthenticationBuilder(new ClaimBuilder().setUser("Bob")
+                .setUserId("1234").addRole("admin").addRole("guest").build()).build();
+
+        as.set(auth);
+        List<Future<Authentication>> fs = Executors.newFixedThreadPool(2).invokeAll(
+                Arrays.asList(new Worker(), new Worker()));
+        for (Future<Authentication> f : fs) {
+            assertEquals(auth, f.get());
+        }
+
+        as.clear();
+        fs = Executors.newFixedThreadPool(2).invokeAll(Arrays.asList(new Worker(), new Worker()));
+        for (Future<Authentication> f : fs) {
+            assertNull(f.get());
+        }
+    }
+
+    @Test
+    public void testUpdatedValid() throws ConfigurationException {
+        Dictionary<String, String> props = new Hashtable<>();
+        AuthenticationManager as = AuthenticationManager.instance();
+
+        assertFalse(as.isAuthEnabled());
+
+        props.put(AuthenticationManager.AUTH_ENABLED, "TrUe");
+        as.updated(props);
+        assertTrue(as.isAuthEnabled());
+
+        props.put(AuthenticationManager.AUTH_ENABLED, "FaLsE");
+        as.updated(props);
+        assertFalse(as.isAuthEnabled());
+    }
+
+    @Test
+    public void testUpdatedNullProperty() throws ConfigurationException {
+        AuthenticationManager as = AuthenticationManager.instance();
+
+        assertFalse(as.isAuthEnabled());
+        as.updated(null);
+        assertFalse(as.isAuthEnabled());
+    }
+
+    @Test(expected = ConfigurationException.class)
+    public void testUpdatedInvalidValue() throws ConfigurationException {
+        AuthenticationManager as = AuthenticationManager.instance();
+        Dictionary<String, String> props = new Hashtable<>();
+
+        props.put(AuthenticationManager.AUTH_ENABLED, "yes");
+        as.updated(props);
+    }
+
+    @Test(expected = ConfigurationException.class)
+    public void testUpdatedInvalidKey() throws ConfigurationException {
+        AuthenticationManager as = AuthenticationManager.instance();
+        Dictionary<String, String> props = new Hashtable<>();
+
+        props.put("Invalid Key", "true");
+        as.updated(props);
+    }
+
+    private class Worker implements Callable<Authentication> {
+        @Override
+        public Authentication call() throws Exception {
+            AuthenticationService as = AuthenticationManager.instance();
+            return as.get();
+        }
+    }
+}
\ No newline at end of file
diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClaimBuilderTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClaimBuilderTest.java
new file mode 100644
index 00000000..372eb6d2
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClaimBuilderTest.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2014, 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+import org.opendaylight.aaa.api.Claim;
+
+/**
+ *
+ * @author liemmn
+ *
+ */
+public class ClaimBuilderTest {
+    @Test
+    public void testBuildWithAll() {
+        Claim c1 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").addRole("foo2")
+                .addRoles(new HashSet<>(Arrays.asList("foo", "bar"))).build();
+        assertEquals("dlux", c1.clientId());
+        assertEquals("pepsi", c1.domain());
+        assertEquals("john", c1.user());
+        assertEquals("1234", c1.userId());
+        assertTrue(c1.roles().contains("foo"));
+        assertTrue(c1.roles().contains("foo2"));
+        assertTrue(c1.roles().contains("bar"));
+        assertEquals(3, c1.roles().size());
+        Claim c2 = new ClaimBuilder(c1).build();
+        assertEquals(c1, c2);
+    }
+
+    @Test
+    public void testBuildWithRequired() {
+        Claim c1 = new ClaimBuilder().setUser("john").setUserId("1234").addRole("foo").build();
+        assertEquals("john", c1.user());
+        assertEquals("1234", c1.userId());
+        assertTrue(c1.roles().contains("foo"));
+        assertEquals(1, c1.roles().size());
+        assertEquals("", c1.domain());
+        assertEquals("", c1.clientId());
+    }
+
+    @Test
+    public void testBuildWithEmptyOptional() {
+        Claim c1 = new ClaimBuilder().setDomain("  ").setClientId("  ").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertEquals("", c1.domain());
+        assertEquals("", c1.clientId());
+        assertEquals("john", c1.user());
+        assertEquals("1234", c1.userId());
+        assertTrue(c1.roles().contains("foo"));
+        assertEquals(1, c1.roles().size());
+    }
+
+    @Test
+    public void testBuildWithNullOptional() {
+        Claim c1 = new ClaimBuilder().setDomain(null).setClientId(null).setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertEquals("", c1.domain());
+        assertEquals("", c1.clientId());
+        assertEquals("john", c1.user());
+        assertEquals("1234", c1.userId());
+        assertTrue(c1.roles().contains("foo"));
+        assertEquals(1, c1.roles().size());
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithDefault() {
+        ClaimBuilder c1 = new ClaimBuilder();
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithoutUser() {
+        ClaimBuilder c1 = new ClaimBuilder().setUserId("1234").addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithNullUser() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser(null).setUserId("1234").addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithEmptyUser() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("  ").setUserId("1234").addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithoutUserId() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithNullUserId() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").setUserId(null).addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithEmptyUserId() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").setUserId("  ").addRole("foo");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithoutRole() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").setUserId("1234");
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithNullRole() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").setUserId("1234").addRole(null);
+        c1.build();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testBuildWithEmptyRole() {
+        ClaimBuilder c1 = new ClaimBuilder().setUser("john").setUserId("1234").addRole("  ");
+        c1.build();
+    }
+
+    @Test
+    public void testEquals() {
+        Claim c1 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertTrue(c1.equals(c1));
+        Claim c2 = new ClaimBuilder(c1).addRole("foo").build();
+        assertTrue(c1.equals(c2));
+        assertTrue(c2.equals(c1));
+        Claim c3 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertTrue(c1.equals(c3));
+        assertTrue(c3.equals(c2));
+        assertTrue(c1.equals(c2));
+    }
+
+    @Test
+    public void testNotEquals() {
+        Claim c1 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertFalse(c1.equals(null));
+        assertFalse(c1.equals("wrong object"));
+        Claim c2 = new ClaimBuilder(c1).addRoles(new HashSet<>(Arrays.asList("foo", "bar")))
+                .build();
+        assertEquals(2, c2.roles().size());
+        assertFalse(c1.equals(c2));
+        assertFalse(c2.equals(c1));
+        Claim c3 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertFalse(c1.equals(c2));
+        assertTrue(c1.equals(c3));
+        assertFalse(c2.equals(c3));
+        Claim c5 = new ClaimBuilder().setUser("john").setUserId("1234").addRole("foo").build();
+        assertFalse(c1.equals(c5));
+        assertFalse(c5.equals(c1));
+    }
+
+    @Test
+    public void testHash() {
+        Claim c1 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertEquals(c1.hashCode(), c1.hashCode());
+        Claim c2 = new ClaimBuilder(c1).addRole("foo").build();
+        assertTrue(c1.equals(c2));
+        assertEquals(c1.hashCode(), c2.hashCode());
+        Claim c3 = new ClaimBuilder(c1).addRoles(new HashSet<>(Arrays.asList("foo", "bar")))
+                .build();
+        assertFalse(c1.equals(c3));
+        assertNotEquals(c1.hashCode(), c3.hashCode());
+        Claim c4 = new ClaimBuilder().setClientId("dlux").setDomain("pepsi").setUser("john")
+                .setUserId("1234").addRole("foo").build();
+        assertTrue(c1.equals(c4));
+        assertEquals(c1.hashCode(), c4.hashCode());
+        assertEquals(c2.hashCode(), c4.hashCode());
+        Claim c5 = new ClaimBuilder().setUser("john").setUserId("1234").addRole("foo").build();
+        assertFalse(c1.equals(c5));
+        assertNotEquals(c1.hashCode(), c5.hashCode());
+    }
+
+    @Test
+    public void testToString() {
+        Claim c1 = new ClaimBuilder().setUser("john").setUserId("1234").addRole("foo").build();
+        assertEquals("clientId:,userId:1234,userName:john,domain:,roles:[foo]", c1.toString());
+        c1 = new ClaimBuilder(c1).setClientId("dlux").setDomain("pepsi").build();
+        assertEquals("clientId:dlux,userId:1234,userName:john,domain:pepsi,roles:[foo]",
+                c1.toString());
+        c1 = new ClaimBuilder(c1).addRole("bar").build();
+        assertEquals("clientId:dlux,userId:1234,userName:john,domain:pepsi,roles:[foo, bar]",
+                c1.toString());
+    }
+}
\ No newline at end of file
diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClientManagerTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClientManagerTest.java
new file mode 100644
index 00000000..059ba9a3
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/ClientManagerTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2014, 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.fail;
+
+import java.util.Dictionary;
+import java.util.Hashtable;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.aaa.api.AuthenticationException;
+import org.osgi.service.cm.ConfigurationException;
+
+/**
+ *
+ * @author liemmn
+ *
+ */
+public class ClientManagerTest {
+    private static final ClientManager cm = new ClientManager();
+
+    @Before
+    public void setup() throws ConfigurationException {
+        cm.init(null);
+    }
+
+    @Test
+    public void testValidate() {
+        cm.validate("dlux", "secrete");
+    }
+
+    @Test(expected = AuthenticationException.class)
+    public void testFailValidate() {
+        cm.validate("dlux", "what?");
+    }
+
+    @Test
+    public void testUpdate() throws ConfigurationException {
+        Dictionary<String, String> configs = new Hashtable<>();
+        configs.put(ClientManager.CLIENTS, "aws:amazon dlux:xxx");
+        cm.updated(configs);
+        cm.validate("aws", "amazon");
+        cm.validate("dlux", "xxx");
+    }
+
+    @Test
+    public void testFailUpdate() {
+        Dictionary<String, String> configs = new Hashtable<>();
+        configs.put(ClientManager.CLIENTS, "aws:amazon dlux");
+        try {
+            cm.updated(configs);
+            fail("Shoulda failed updating bad configuration");
+        } catch (ConfigurationException ce) {
+            // Expected
+        }
+        cm.validate("dlux", "secrete");
+        try {
+            cm.validate("aws", "amazon");
+            fail("Shoulda failed updating bad configuration");
+        } catch (AuthenticationException ae) {
+            // Expected
+        }
+    }
+}
diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/PasswordCredentialTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/PasswordCredentialTest.java
new file mode 100644
index 00000000..2dabb77b
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/PasswordCredentialTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2014, 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.HashSet;
+import org.junit.Test;
+import org.opendaylight.aaa.api.PasswordCredentials;
+
+public class PasswordCredentialTest {
+
+    @Test
+    public void testBuilder() {
+        PasswordCredentials pc1 = new PasswordCredentialBuilder().setUserName("bob")
+                .setPassword("secrete").build();
+        assertEquals("bob", pc1.username());
+        assertEquals("secrete", pc1.password());
+
+        PasswordCredentials pc2 = new PasswordCredentialBuilder().setUserName("bob")
+                .setPassword("secrete").build();
+        assertEquals(pc1, pc2);
+
+        PasswordCredentials pc3 = new PasswordCredentialBuilder().setUserName("bob")
+                .setPassword("secret").build();
+        HashSet<PasswordCredentials> pcs = new HashSet<>();
+        pcs.add(pc1);
+        pcs.add(pc2);
+        pcs.add(pc3);
+        assertEquals(2, pcs.size());
+    }
+
+}
diff --git a/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/SecureBlockingQueueTest.java b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/SecureBlockingQueueTest.java
new file mode 100644
index 00000000..16627d9f
--- /dev/null
+++ b/odl-aaa-moon/aaa/aaa-authn/src/test/java/org/opendaylight/aaa/SecureBlockingQueueTest.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2014, 2015 Hewlett-Packard Development Company, L.P. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.aaa;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.aaa.SecureBlockingQueue.SecureData;
+import org.opendaylight.aaa.api.Authentication;
+
+public class SecureBlockingQueueTest {
+    private final int MAX_TASKS = 100;
+
+    @Before
+    public void setup() {
+        AuthenticationManager.instance().clear();
+    }
+
+    @Test
+    public void testSecureThreadPoolExecutor() throws InterruptedException, ExecutionException {
+        BlockingQueue<Runnable> queue = new SecureBlockingQueue<>(
+                new ArrayBlockingQueue<SecureData<Runnable>>(10));
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 500, TimeUnit.MILLISECONDS,
+                queue);
+        executor.prestartAllCoreThreads();
+        for (int cnt = 1; cnt <= MAX_TASKS; cnt++) {
+            assertEquals(Integer.toString(cnt),
+                    executor.submit(new Task(Integer.toString(cnt), "1111", "user")).get().user());
+        }
+        executor.shutdown();
+    }
+
+    @Test
+    public void testNormalThreadPoolExecutor() throws InterruptedException, ExecutionException {
+        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(10);
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 500, TimeUnit.MILLISECONDS,
+                queue);
+        executor.prestartAllCoreThreads();
+        for (int cnt = 1; cnt <= MAX_TASKS; cnt++) {
+            assertNull(executor.submit(new Task(Integer.toString(cnt), "1111", "user")).get());
+        }
+        executor.shutdown();
+    }
+
+    @Test
+    public void testQueueOps() throws InterruptedException, ExecutionException {
+        BlockingQueue<String> queue = new SecureBlockingQueue<>(
+                new ArrayBlockingQueue<SecureData<String>>(3));
+        ExecutorService es = Executors.newFixedThreadPool(3);
+        es.submit(new Producer("foo", "1111", "user", queue)).get();
+        assertEquals(1, queue.size());
+        assertEquals("foo", es.submit(new Consumer(queue)).get());
+        es.submit(new Producer("bar", "2222", "user", queue)).get();
+        assertEquals("bar", queue.peek());
+        assertEquals("bar", queue.element());
+        assertEquals(1, queue.size());
+        assertEquals("bar", queue.poll());
+        assertTrue(queue.isEmpty());
+        es.shutdown();
+    }
+
+    @Test
+    public void testCollectionOps() throws InterruptedException, ExecutionException {
+        BlockingQueue<String> queue = new SecureBlockingQueue<>(
+                new ArrayBlockingQueue<SecureData<String>>(6));
+        for (int i = 1; i <= 3; i++)
+            queue.add("User" + i);
+        Iterator<String> it = queue.iterator();
+        while (it.hasNext())
+            assertTrue(it.next().startsWith("User"));
+        assertEquals(3, queue.toArray().length);
+        List<String> actual = Arrays.asList(queue.toArray(new String[0]));
+        assertEquals("User1", actual.iterator().next());
+        assertTrue(queue.containsAll(actual));
+        queue.addAll(actual);
+        assertEquals(6, queue.size());
+        queue.retainAll(Arrays.asList(new String[] { "User2" }));
+        assertEquals(2, queue.size());
+        assertEquals("User2", queue.iterator().next());
+        queue.removeAll(actual);
+        assertTrue(queue.isEmpty());
+        queue.add("hello");
+        assertEquals(1, queue.size());
+        queue.clear();
+        assertTrue(queue.isEmpty());
+    }
+
+    @Test
+    public void testBlockingQueueOps() throws InterruptedException {
+        BlockingQueue<String> queue = new SecureBlockingQueue<>(
+                new ArrayBlockingQueue<SecureData<String>>(3));
+        queue.offer("foo");
+        assertEquals(1, queue.size());
+        queue.offer("bar", 500, TimeUnit.MILLISECONDS);
+        assertEquals(2, queue.size());
+        assertEquals("foo", queue.poll());
+        assertTrue(queue.contains("bar"));
+        queue.remove("bar");
+        assertEquals(3, queue.remainingCapacity());
+        queue.addAll(Arrays.asList(new String[] { "foo", "bar", "tom" }));
+        assertEquals(3, queue.size());
+        assertEquals("foo", queue.poll(500, TimeUnit.MILLISECONDS));
+        assertEquals(2, queue.size());
+        List<String> drain = new LinkedList<>();
+        queue.drainTo(drain);
+        assertTrue(queue.isEmpty());
+        assertEquals(2, drain.size());
+        queue.addAll(Arrays.asList(new String[] { "foo", "bar", "tom" }));
+        drain.clear();
+        queue.drainTo(drain, 1);
+        assertEquals(2, queue.size());
+        assertEquals(1, drain.size());
+    }
+
+    // Task to run in a ThreadPoolExecutor
+    private class Task implements Callable<Authentication> {
+        Task(String name, String userId, String role) {
+            // Mock that each task has its original authentication context
+            AuthenticationManager.instance().set(
+                    new AuthenticationBuilder(new ClaimBuilder().setUser(name).setUserId(userId)
+                            .addRole(role).build()).build());
+        }
+
+        @Override
+        public Authentication call() throws Exception {
+            return AuthenticationManager.instance().get();
+        }
+    }
+
+    // Producer sets auth context
+    private class Producer implements Callable<String> {
+        private final String name;
+        private final String userId;
+        private final String role;
+        private final BlockingQueue<String> queue;
+
+        Producer(String name, String userId, String role, BlockingQueue<String> queue) {
+            this.name = name;
+            this.userId = userId;
+            this.role = role;
+            this.queue = queue;
+        }
+
+        @Override
+        public String call() throws InterruptedException {
+            AuthenticationManager.instance().set(
+                    new AuthenticationBuilder(new ClaimBuilder().setUser(name).setUserId(userId)
+                            .addRole(role).build()).build());
+            queue.put(name);
+            return name;
+        }
+    }
+
+    // Consumer gets producer's auth context via data element in queue
+    private class Consumer implements Callable<String> {
+        private final BlockingQueue<String> queue;
+
+        Consumer(BlockingQueue<String> queue) {
+            this.queue = queue;
+        }
+
+        @Override
+        public String call() {
+            queue.remove();
+            Authentication auth = AuthenticationManager.instance().get();
+            return (auth == null) ? null : auth.user();
+        }
+    }
+
+}