QPID-4236, QPID-4237, QPID-4245: Added group management functionality, and exposed it via the web management interface. Removed group definition functionality from the ACL plugin. The ACL plugin uses groups but no longer defines them.

Introduced SubjectCreator as a facade to AuthenticationManager and group
management classes.

Applied access control to user and group management.

Fixed bug in choosing between update and creation in RestServlet.

Moved lots of RestTest helper methods to RestTestHelper.

Fixed authentication, authorisation, and status logging when using the web ui.

Applied patch from Philip Harvey <phil@philharveyonline.com>, Keith Wall and myself.

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@1376968 13f79535-47bb-0310-9956-ffa450edef68

23 files changed, 1550 insertions, 201 deletions

diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/AbstractManagementActorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/AbstractManagementActorTest.java
new file mode 100644
index 0000000000..bf38bb64bf
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/AbstractManagementActorTest.java
@@ -0,0 +1,86 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.logging.actors;
+
+import java.security.Principal;
+import java.security.PrivilegedAction;
+import java.util.Collections;
+
+import javax.security.auth.Subject;
+
+import org.apache.qpid.server.logging.NullRootMessageLogger;
+import org.apache.qpid.server.security.auth.TestPrincipalUtils;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+public class AbstractManagementActorTest extends QpidTestCase
+{
+    private AbstractManagementActor _logActor;
+
+    @Override
+    public void setUp()
+    {
+        _logActor = new AbstractManagementActor(new NullRootMessageLogger(), AbstractManagementActor.UNKNOWN_PRINCIPAL)
+        {
+            @Override
+            public String getLogMessage()
+            {
+                return null;
+            }
+        };
+    }
+
+    public void testGetPrincipalName()
+    {
+        Subject subject = TestPrincipalUtils.createTestSubject("guest");
+        
+        final String principalName = Subject.doAs(subject, 
+                new PrivilegedAction<String>()
+                {
+                    public String run()
+                    {
+                        return _logActor.getPrincipalName();
+                    }
+                });
+
+        assertEquals("guest", principalName);
+    }
+
+    public void testGetPrincipalNameUsingSubjectWithoutAuthenticatedPrincipal()
+    {
+        Subject subject = new Subject(true, Collections.<Principal>emptySet(), Collections.emptySet(), Collections.emptySet());
+
+        final String principalName = Subject.doAs(subject, 
+                new PrivilegedAction<String>()
+                {
+                    public String run()
+                    {
+                        return _logActor.getPrincipalName();
+                    }
+                });
+
+        assertEquals(AbstractManagementActor.UNKNOWN_PRINCIPAL, principalName);
+    }
+
+    public void testGetPrincipalWithoutSubject()
+    {
+        assertEquals(AbstractManagementActor.UNKNOWN_PRINCIPAL, _logActor.getPrincipalName());
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/HttpManagementActorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/HttpManagementActorTest.java
new file mode 100644
index 0000000000..b40405e1f4
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/HttpManagementActorTest.java
@@ -0,0 +1,94 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.logging.actors;
+
+import javax.security.auth.Subject;
+
+import org.apache.qpid.server.security.auth.TestPrincipalUtils;
+
+import java.security.PrivilegedAction;
+import java.util.List;
+
+public class HttpManagementActorTest extends BaseActorTestCase
+{
+    private static final String IP = "127.0.0.1";
+    private static final int PORT = 1;
+    private static final String SUFFIX = "(" + IP + ":" + PORT + ")] ";
+
+    @Override
+    public void createBroker() throws Exception
+    {
+        super.createBroker();
+        _amqpActor = new HttpManagementActor(_rootLogger, IP, PORT);
+    }
+
+    public void testSubjectPrincipalNameAppearance()
+    {
+        Subject subject = TestPrincipalUtils.createTestSubject("guest");
+
+        final String message = Subject.doAs(subject, new PrivilegedAction<String>()
+        {
+            public String run()
+            {
+                return sendTestLogMessage(_amqpActor);
+            }
+        });
+
+        assertNotNull("Test log message is not created!", message);
+
+        List<Object> logs = _rawLogger.getLogMessages();
+        assertEquals("Message log size not as expected.", 1, logs.size());
+
+        String logMessage = logs.get(0).toString();
+        assertTrue("Message was not found in log message", logMessage.contains(message));
+        assertTrue("Message does not contain expected value: " + logMessage, logMessage.contains("[mng:guest" + SUFFIX));
+    }
+
+    /** It's necessary to test successive calls because HttpManagementActor caches
+     *  its log message based on principal name */
+    public void testGetLogMessageCaching()
+    {
+        assertLogMessageWithoutPrincipal();
+        assertLogMessageWithPrincipal("my_principal");
+        assertLogMessageWithPrincipal("my_principal2");
+        assertLogMessageWithoutPrincipal();
+    }
+
+    private void assertLogMessageWithoutPrincipal()
+    {
+        String message = _amqpActor.getLogMessage();
+        assertEquals("Unexpected log message", "[mng:" + AbstractManagementActor.UNKNOWN_PRINCIPAL + SUFFIX, message);
+    }
+
+    private void assertLogMessageWithPrincipal(String principalName)
+    {
+        Subject subject = TestPrincipalUtils.createTestSubject(principalName);
+        final String message = Subject.doAs(subject, new PrivilegedAction<String>()
+        {
+            public String run()
+            {
+                return _amqpActor.getLogMessage();
+            }
+        });
+
+        assertEquals("Unexpected log message", "[mng:" + principalName + SUFFIX, message);
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/ManagementActorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/ManagementActorTest.java
index cb866245f0..20cc321aab 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/ManagementActorTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/actors/ManagementActorTest.java
@@ -20,10 +20,11 @@
  */
 package org.apache.qpid.server.logging.actors;
 
-import javax.management.remote.JMXPrincipal;
 import javax.security.auth.Subject;
+
+import org.apache.qpid.server.security.auth.TestPrincipalUtils;
+
 import java.security.PrivilegedAction;
-import java.util.Collections;
 import java.util.List;
 
 public class ManagementActorTest extends BaseActorTestCase
@@ -94,8 +95,7 @@ public class ManagementActorTest extends BaseActorTestCase
      */
     public void testSubjectPrincipalNameAppearance()
     {
-        Subject subject = new Subject(true, Collections.singleton(new JMXPrincipal("guest")), Collections.EMPTY_SET,
-                Collections.EMPTY_SET);
+        Subject subject = TestPrincipalUtils.createTestSubject("guest");
 
         final String message = Subject.doAs(subject, new PrivilegedAction<String>()
         {
@@ -172,9 +172,7 @@ public class ManagementActorTest extends BaseActorTestCase
     private void assertLogMessageInRMIThreadWithPrincipal(String threadName, String principalName)
     {
         Thread.currentThread().setName(threadName);
-        Subject subject = new Subject(true, Collections.singleton(new JMXPrincipal(principalName)), Collections.EMPTY_SET,
-                Collections.EMPTY_SET);
-
+        Subject subject = TestPrincipalUtils.createTestSubject(principalName);
         final String message = Subject.doAs(subject, new PrivilegedAction<String>()
         {
             public String run()
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/model/UUIDGeneratorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/model/UUIDGeneratorTest.java
index 643132d371..c686a24e99 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/model/UUIDGeneratorTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/model/UUIDGeneratorTest.java
@@ -70,8 +70,12 @@ public class UUIDGeneratorTest extends QpidTestCase
         idSet.add(id6);
         UUID id7 = UUIDGenerator.generateVhostAliasUUID(value, value);
         idSet.add(id7);
+        UUID id8 = UUIDGenerator.generateGroupUUID(value, value);
+        idSet.add(id8);
+        UUID id9 = UUIDGenerator.generateGroupMemberUUID(value, value, value);
+        idSet.add(id9);
 
-        assertEquals("The produced UUIDs were not all unique", 7, idSet.size());
+        assertEquals("The produced UUIDs were not all unique", 9, idSet.size());
     }
 
     public void testQueueIdGeneration() throws Exception
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/protocol/InternalTestProtocolSession.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/protocol/InternalTestProtocolSession.java
index 96c67941f9..0016e31236 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/protocol/InternalTestProtocolSession.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/protocol/InternalTestProtocolSession.java
@@ -31,7 +31,8 @@ import org.apache.qpid.server.message.MessageContentSource;
 import org.apache.qpid.server.output.ProtocolOutputConverter;
 import org.apache.qpid.server.queue.QueueEntry;
 import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.server.security.auth.sasl.UsernamePrincipal;
+import org.apache.qpid.server.security.auth.AuthenticatedPrincipal;
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
 import org.apache.qpid.server.subscription.ClientDeliveryMethod;
 import org.apache.qpid.server.subscription.Subscription;
 import org.apache.qpid.server.subscription.SubscriptionImpl;
@@ -39,6 +40,8 @@ import org.apache.qpid.server.virtualhost.VirtualHost;
 import org.apache.qpid.transport.TestNetworkConnection;
 
 import javax.security.auth.Subject;
+
+import java.security.Principal;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -61,13 +64,22 @@ public class InternalTestProtocolSession extends AMQProtocolEngine implements Pr
 
         _channelDelivers = new HashMap<Integer, Map<AMQShortString, LinkedList<DeliveryPair>>>();
 
-        // Need to authenticate session for it to be representative testing.
-        setAuthorizedSubject(new Subject(true, Collections.singleton(new UsernamePrincipal("InternalTestProtocolSession")),
-                Collections.EMPTY_SET, Collections.EMPTY_SET));
-
+        setTestAuthorizedSubject();
         setVirtualHost(virtualHost);
     }
 
+    private void setTestAuthorizedSubject()
+    {
+        Principal principal = new AuthenticatedPrincipal(new UsernamePrincipal("InternalTestProtocolSession"));
+        Subject authorizedSubject = new Subject(
+                true,
+                Collections.singleton(principal),
+                Collections.emptySet(),
+                Collections.emptySet());
+
+        setAuthorizedSubject(authorizedSubject);
+    }
+
     public ProtocolOutputConverter getProtocolOutputConverter()
     {
         return this;
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/SubjectCreatorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/SubjectCreatorTest.java
new file mode 100644
index 0000000000..b1bc9bea68
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/SubjectCreatorTest.java
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.security.Principal;
+import java.util.Arrays;
+import java.util.HashSet;
+
+import javax.security.auth.Subject;
+import javax.security.sasl.SaslServer;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.server.security.auth.AuthenticatedPrincipal;
+import org.apache.qpid.server.security.auth.AuthenticationResult;
+import org.apache.qpid.server.security.auth.AuthenticationResult.AuthenticationStatus;
+import org.apache.qpid.server.security.auth.SubjectAuthenticationResult;
+import org.apache.qpid.server.security.auth.manager.AuthenticationManager;
+import org.apache.qpid.server.security.group.GroupPrincipalAccessor;
+
+public class SubjectCreatorTest extends TestCase
+{
+    private static final String USERNAME = "username";
+    private static final String PASSWORD = "password";
+
+    private AuthenticationManager _authenticationManager = mock(AuthenticationManager.class);
+    private GroupPrincipalAccessor _groupPrincipalAccessor = mock(GroupPrincipalAccessor.class);
+    private SubjectCreator _subjectCreator = new SubjectCreator(_authenticationManager, _groupPrincipalAccessor);
+
+    private Principal _userPrincipal = mock(Principal.class);
+    private Principal _group1 = mock(Principal.class);
+    private Principal _group2 = mock(Principal.class);
+
+    private AuthenticationResult _authenticationResult;
+    private SaslServer _testSaslServer = mock(SaslServer.class);
+    private byte[] _saslResponseBytes = PASSWORD.getBytes();
+
+    @Override
+    public void setUp()
+    {
+        _authenticationResult = new AuthenticationResult(_userPrincipal);
+        when(_authenticationManager.authenticate(USERNAME, PASSWORD)).thenReturn(_authenticationResult);
+
+        when(_groupPrincipalAccessor.getGroupPrincipals(USERNAME))
+            .thenReturn(new HashSet<Principal>(Arrays.asList(_group1, _group2)));
+    }
+
+    public void testAuthenticateUsernameAndPasswordReturnsSubjectWithUserAndGroupPrincipals()
+    {
+        final SubjectAuthenticationResult actualResult = _subjectCreator.authenticate(USERNAME, PASSWORD);
+
+        assertEquals(AuthenticationStatus.SUCCESS, actualResult.getStatus());
+
+        final Subject actualSubject = actualResult.getSubject();
+
+        assertEquals("Should contain one user principal and two groups ", 3, actualSubject.getPrincipals().size());
+
+        assertTrue(actualSubject.getPrincipals().contains(new AuthenticatedPrincipal(_userPrincipal)));
+        assertTrue(actualSubject.getPrincipals().contains(_group1));
+        assertTrue(actualSubject.getPrincipals().contains(_group2));
+
+        assertTrue(actualSubject.isReadOnly());
+    }
+
+    public void testSaslAuthenticationSuccessReturnsSubjectWithUserAndGroupPrincipals() throws Exception
+    {
+        when(_authenticationManager.authenticate(_testSaslServer, _saslResponseBytes)).thenReturn(_authenticationResult);
+        when(_testSaslServer.isComplete()).thenReturn(true);
+        when(_testSaslServer.getAuthorizationID()).thenReturn(USERNAME);
+
+        SubjectAuthenticationResult result = _subjectCreator.authenticate(_testSaslServer, _saslResponseBytes);
+
+        final Subject actualSubject = result.getSubject();
+        assertEquals("Should contain one user principal and two groups ", 3, actualSubject.getPrincipals().size());
+
+        assertTrue(actualSubject.getPrincipals().contains(new AuthenticatedPrincipal(_userPrincipal)));
+        assertTrue(actualSubject.getPrincipals().contains(_group1));
+        assertTrue(actualSubject.getPrincipals().contains(_group2));
+
+        assertTrue(actualSubject.isReadOnly());
+    }
+
+    public void testAuthenticateUnsuccessfulWithUsernameReturnsNullSubjectAndCorrectStatus()
+    {
+        testUnsuccessfulAuthentication(AuthenticationResult.AuthenticationStatus.CONTINUE);
+        testUnsuccessfulAuthentication(AuthenticationResult.AuthenticationStatus.ERROR);
+    }
+
+    private void testUnsuccessfulAuthentication(AuthenticationStatus expectedStatus)
+    {
+        AuthenticationResult failedAuthenticationResult = new AuthenticationResult(expectedStatus);
+
+        when(_authenticationManager.authenticate(USERNAME, PASSWORD)).thenReturn(failedAuthenticationResult);
+
+        SubjectAuthenticationResult subjectAuthenticationResult = _subjectCreator.authenticate(USERNAME, PASSWORD);
+
+        assertSame(expectedStatus, subjectAuthenticationResult.getStatus());
+        assertNull(subjectAuthenticationResult.getSubject());
+    }
+
+    public void testAuthenticateUnsuccessfulWithSaslServerReturnsNullSubjectAndCorrectStatus()
+    {
+        testUnsuccessfulAuthenticationWithSaslServer(AuthenticationResult.AuthenticationStatus.CONTINUE);
+        testUnsuccessfulAuthenticationWithSaslServer(AuthenticationResult.AuthenticationStatus.ERROR);
+    }
+
+    private void testUnsuccessfulAuthenticationWithSaslServer(AuthenticationStatus expectedStatus)
+    {
+        AuthenticationResult failedAuthenticationResult = new AuthenticationResult(expectedStatus);
+
+        when(_authenticationManager.authenticate(_testSaslServer, _saslResponseBytes)).thenReturn(failedAuthenticationResult);
+        when(_testSaslServer.isComplete()).thenReturn(false);
+
+        SubjectAuthenticationResult subjectAuthenticationResult = _subjectCreator.authenticate(_testSaslServer, _saslResponseBytes);
+
+        assertSame(expectedStatus, subjectAuthenticationResult.getStatus());
+        assertNull(subjectAuthenticationResult.getSubject());
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTest.java
new file mode 100644
index 0000000000..cd5791952f
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTest.java
@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.auth;
+
+import java.security.Principal;
+
+import javax.security.auth.Subject;
+
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
+
+import junit.framework.TestCase;
+
+public class AuthenticatedPrincipalTest extends TestCase
+{
+
+    private AuthenticatedPrincipal _authenticatedPrincipal = new AuthenticatedPrincipal(new UsernamePrincipal("name"));
+
+    public void testGetAuthenticatedPrincipalFromSubject()
+    {
+        final Subject subject = createSubjectContainingAuthenticatedPrincipal();
+        final AuthenticatedPrincipal actual = AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(subject);
+        assertSame(_authenticatedPrincipal, actual);
+    }
+
+    public void testAuthenticatedPrincipalNotInSubject()
+    {
+        try
+        {
+            AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(new Subject());
+            fail("Exception not thrown");
+        }
+        catch (IllegalArgumentException iae)
+        {
+            // PASS
+        }
+    }
+
+    public void testGetOptionalAuthenticatedPrincipalFromSubject()
+    {
+        final Subject subject = createSubjectContainingAuthenticatedPrincipal();
+        final AuthenticatedPrincipal actual = AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subject);
+        assertSame(_authenticatedPrincipal, actual);
+    }
+
+    public void testGetOptionalAuthenticatedPrincipalFromSubjectReturnsNullIfMissing()
+    {
+        Subject subjectWithNoPrincipals = new Subject();
+        assertNull(AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subjectWithNoPrincipals));
+
+        Subject subjectWithoutAuthenticatedPrincipal = new Subject();
+        subjectWithoutAuthenticatedPrincipal.getPrincipals().add(new UsernamePrincipal("name1"));
+        assertNull("Should return null for a subject containing a principal that isn't an AuthenticatedPrincipal",
+                AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subjectWithoutAuthenticatedPrincipal));
+    }
+
+    public void testTooManyAuthenticatedPrincipalsInSubject()
+    {
+        final Subject subject = new Subject();
+        subject.getPrincipals().add(new AuthenticatedPrincipal(new UsernamePrincipal("name1")));
+        subject.getPrincipals().add(new AuthenticatedPrincipal(new UsernamePrincipal("name2")));
+
+        try
+        {
+            AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(subject);
+            fail("Exception not thrown");
+        }
+        catch (IllegalArgumentException iae)
+        {
+            // PASS
+        }
+    }
+
+    private Subject createSubjectContainingAuthenticatedPrincipal()
+    {
+        final Principal other = new Principal()
+        {
+            public String getName()
+            {
+                return "otherprincipal";
+            }
+        };
+
+        final Subject subject = new Subject();
+        subject.getPrincipals().add(_authenticatedPrincipal);
+        subject.getPrincipals().add(other);
+        return subject;
+    }
+
+    public void testEqualsAndHashcode()
+    {
+        AuthenticatedPrincipal user1principal1 = new AuthenticatedPrincipal(new UsernamePrincipal("user1"));
+        AuthenticatedPrincipal user1principal2 = new AuthenticatedPrincipal(new UsernamePrincipal("user1"));
+
+        assertTrue(user1principal1.equals(user1principal1));
+        assertTrue(user1principal1.equals(user1principal2));
+        assertTrue(user1principal2.equals(user1principal1));
+
+        assertEquals(user1principal1.hashCode(), user1principal2.hashCode());
+    }
+
+    public void testEqualsAndHashcodeWithSameWrappedObject()
+    {
+        UsernamePrincipal wrappedPrincipal = new UsernamePrincipal("user1");
+        AuthenticatedPrincipal user1principal1 = new AuthenticatedPrincipal(wrappedPrincipal);
+        AuthenticatedPrincipal user1principal2 = new AuthenticatedPrincipal(wrappedPrincipal);
+
+        assertTrue(user1principal1.equals(user1principal1));
+        assertTrue(user1principal1.equals(user1principal2));
+        assertTrue(user1principal2.equals(user1principal1));
+
+        assertEquals(user1principal1.hashCode(), user1principal2.hashCode());
+    }
+
+    public void testEqualsWithDifferentUsernames()
+    {
+        AuthenticatedPrincipal user1principal1 = new AuthenticatedPrincipal(new UsernamePrincipal("user1"));
+        AuthenticatedPrincipal user1principal2 = new AuthenticatedPrincipal(new UsernamePrincipal("user2"));
+
+        assertFalse(user1principal1.equals(user1principal2));
+        assertFalse(user1principal2.equals(user1principal1));
+    }
+
+    public void testEqualsWithDisimilarObjects()
+    {
+        UsernamePrincipal wrappedPrincipal = new UsernamePrincipal("user1");
+        AuthenticatedPrincipal authenticatedPrincipal = new AuthenticatedPrincipal(wrappedPrincipal);
+
+        assertFalse(authenticatedPrincipal.equals(wrappedPrincipal));
+        assertFalse(wrappedPrincipal.equals(authenticatedPrincipal));
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTestHelper.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTestHelper.java
new file mode 100644
index 0000000000..e9d8d16fce
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticatedPrincipalTestHelper.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.auth;
+
+import java.security.Principal;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.Assert;
+
+/**
+ * Helper class for testing that sets of principals contain {@link AuthenticatedPrincipal}'s that wrap
+ * expected {@link Principal}'s.
+ */
+public class AuthenticatedPrincipalTestHelper
+{
+    public static void assertOnlyContainsWrapped(Principal wrappedPrincipal, Set<Principal> principals)
+    {
+        assertOnlyContainsWrappedAndSecondaryPrincipals(wrappedPrincipal, Collections.<Principal>emptySet(), principals);
+    }
+
+
+    public static void assertOnlyContainsWrappedAndSecondaryPrincipals(
+            Principal      expectedWrappedPrincipal,
+            Set<Principal> expectedSecondaryPrincipals,
+            Set<Principal> actualPrincipals)
+    {
+        Assert.assertEquals("Principal set should contain one principal " + "but the principal set is: " + actualPrincipals,
+                1 + expectedSecondaryPrincipals.size(),
+                actualPrincipals.size());
+
+        Set<Principal> expectedSet = new HashSet<Principal>(expectedSecondaryPrincipals);
+        expectedSet.add(new AuthenticatedPrincipal(expectedWrappedPrincipal));
+
+        Assert.assertEquals(expectedSet, actualPrincipals);
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticationResultTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticationResultTest.java
new file mode 100644
index 0000000000..a023cbdbb2
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/AuthenticationResultTest.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.auth;
+
+import static org.apache.qpid.server.security.auth.AuthenticatedPrincipalTestHelper.assertOnlyContainsWrapped;
+import static org.apache.qpid.server.security.auth.AuthenticatedPrincipalTestHelper.assertOnlyContainsWrappedAndSecondaryPrincipals;
+import static org.mockito.Mockito.mock;
+
+import java.security.Principal;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+public class AuthenticationResultTest extends TestCase
+{
+    public void testConstructWithAuthenticationStatusContinue()
+    {
+        AuthenticationResult authenticationResult = new AuthenticationResult(AuthenticationResult.AuthenticationStatus.CONTINUE);
+        assertSame(AuthenticationResult.AuthenticationStatus.CONTINUE, authenticationResult.getStatus());
+        assertTrue(authenticationResult.getPrincipals().isEmpty());
+    }
+
+    public void testConstructWithAuthenticationStatusError()
+    {
+        AuthenticationResult authenticationResult = new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR);
+        assertSame(AuthenticationResult.AuthenticationStatus.ERROR, authenticationResult.getStatus());
+        assertTrue(authenticationResult.getPrincipals().isEmpty());
+    }
+
+    public void testConstructWithAuthenticationStatusSuccessThrowsException()
+    {
+        try
+        {
+            new AuthenticationResult(AuthenticationResult.AuthenticationStatus.SUCCESS);
+            fail("Exception not thrown");
+        }
+        catch(IllegalArgumentException e)
+        {
+            // PASS
+        }
+    }
+
+    public void testConstructWithPrincipal()
+    {
+        Principal mainPrincipal = mock(Principal.class);
+        AuthenticationResult authenticationResult = new AuthenticationResult(mainPrincipal);
+
+        assertOnlyContainsWrapped(mainPrincipal, authenticationResult.getPrincipals());
+        assertSame(AuthenticationResult.AuthenticationStatus.SUCCESS, authenticationResult.getStatus());
+    }
+
+    public void testConstructWithNullPrincipalThrowsException()
+    {
+        try
+        {
+            new AuthenticationResult((Principal)null);
+            fail("Exception not thrown");
+        }
+        catch(IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testConstructWithSetOfPrincipals()
+    {
+        Principal mainPrincipal = mock(Principal.class);
+        Principal secondaryPrincipal = mock(Principal.class);
+        Set<Principal> secondaryPrincipals = Collections.singleton(secondaryPrincipal);
+
+        AuthenticationResult authenticationResult = new AuthenticationResult(mainPrincipal, secondaryPrincipals);
+
+        assertOnlyContainsWrappedAndSecondaryPrincipals(mainPrincipal, secondaryPrincipals, authenticationResult.getPrincipals());
+        assertSame(AuthenticationResult.AuthenticationStatus.SUCCESS, authenticationResult.getStatus());
+    }
+
+    public void testConstructWithSetOfPrincipalsDeDuplicatesMainPrincipal()
+    {
+        Principal mainPrincipal = mock(Principal.class);
+        Principal secondaryPrincipal = mock(Principal.class);
+
+        Set<Principal> secondaryPrincipalsContainingDuplicateOfMainPrincipal = new HashSet<Principal>(
+                Arrays.asList(secondaryPrincipal, mainPrincipal));
+        Set<Principal> deDuplicatedSecondaryPrincipals = Collections.singleton(secondaryPrincipal);
+
+        AuthenticationResult authenticationResult = new AuthenticationResult(
+                mainPrincipal, secondaryPrincipalsContainingDuplicateOfMainPrincipal);
+
+        assertOnlyContainsWrappedAndSecondaryPrincipals(mainPrincipal, deDuplicatedSecondaryPrincipals, authenticationResult.getPrincipals());
+
+        assertSame(AuthenticationResult.AuthenticationStatus.SUCCESS, authenticationResult.getStatus());
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/TestPrincipalUtils.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/TestPrincipalUtils.java
index 7ce03eaa79..ea6b40e3de 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/TestPrincipalUtils.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/TestPrincipalUtils.java
@@ -18,9 +18,12 @@
  * under the License.
  *
  */
-package org.apache.qpid.server.security.auth.sasl;
+package org.apache.qpid.server.security.auth;
 
 import javax.security.auth.Subject;
+
+import org.apache.qpid.server.security.group.GroupPrincipal;
+
 import java.security.Principal;
 import java.util.Collections;
 import java.util.HashSet;
@@ -28,21 +31,19 @@ import java.util.Set;
 
 public class TestPrincipalUtils
 {
-
     /**
-     * Creates a test subject, with exactly one UsernamePrincipal and zero or more GroupPrincipals.
+     * Creates a test subject, with exactly one {@link AuthenticatedPrincipal} and zero or more GroupPrincipals.
      */
     public static Subject createTestSubject(final String username, final String... groups)
     {
         final Set<Principal> principals = new HashSet<Principal>(1 + groups.length);
-        principals.add(new UsernamePrincipal(username));
+        principals.add(new AuthenticatedPrincipal(username));
         for (String group : groups)
         {
             principals.add(new GroupPrincipal(group));
         }
-        
-        final Subject subject = new Subject(true, principals, Collections.EMPTY_SET, Collections.EMPTY_SET);
-        return subject;
+
+        return new Subject(true, principals, Collections.EMPTY_SET, Collections.EMPTY_SET);
     }
 
 }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/UsernamePrincipalTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/UsernamePrincipalTest.java
index 75bc76c688..5e025d3ca8 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/UsernamePrincipalTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/UsernamePrincipalTest.java
@@ -18,13 +18,10 @@
  * under the License.
  *
  */
-package org.apache.qpid.server.security.auth.sasl;
+package org.apache.qpid.server.security.auth;
 
 import junit.framework.TestCase;
 
-import javax.security.auth.Subject;
-import java.security.Principal;
-
 /**
  * Tests the UsernamePrincipal.
  *
@@ -70,54 +67,4 @@ public class UsernamePrincipalTest extends TestCase
         UsernamePrincipal principal = new UsernamePrincipal("string");
         assertFalse(principal.equals(null));
     }
-
-    public void testGetUsernamePrincipalFromSubject()
-    {
-        final UsernamePrincipal expected = new UsernamePrincipal("name");
-        final Principal other = new Principal()
-        {
-            public String getName()
-            {
-                return "otherprincipal";
-            }
-        };
-
-        final Subject subject = new Subject();
-        subject.getPrincipals().add(expected);
-        subject.getPrincipals().add(other);
-
-        final UsernamePrincipal actual = UsernamePrincipal.getUsernamePrincipalFromSubject(subject);
-        assertSame(expected, actual);
-    }
-
-    public void testUsernamePrincipalNotInSubject()
-    {
-        try
-        {
-            UsernamePrincipal.getUsernamePrincipalFromSubject(new Subject());
-            fail("Exception not thrown");
-        }
-        catch (IllegalArgumentException iae)
-        {
-            // PASS
-        }
-    }
-
-    public void testTooManyUsernamePrincipalInSubject()
-    {
-        final Subject subject = new Subject();
-        subject.getPrincipals().add(new UsernamePrincipal("name1"));
-        subject.getPrincipals().add(new UsernamePrincipal("name2"));
-        try
-        {
-
-            UsernamePrincipal.getUsernamePrincipalFromSubject(subject);
-            fail("Exception not thrown");
-        }
-        catch (IllegalArgumentException iae)
-        {
-            // PASS
-        }
-    }
-
 }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/Base64MD5PasswordFilePrincipalDatabaseTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/Base64MD5PasswordFilePrincipalDatabaseTest.java
index 33740af1e7..7b244e219e 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/Base64MD5PasswordFilePrincipalDatabaseTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/Base64MD5PasswordFilePrincipalDatabaseTest.java
@@ -23,7 +23,7 @@ package org.apache.qpid.server.security.auth.database;
 import junit.framework.TestCase;
 import org.apache.commons.codec.binary.Base64;
 
-import org.apache.qpid.server.security.auth.sasl.UsernamePrincipal;
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
 
 import javax.security.auth.callback.PasswordCallback;
 import javax.security.auth.login.AccountNotFoundException;
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/PlainPasswordFilePrincipalDatabaseTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/PlainPasswordFilePrincipalDatabaseTest.java
index b8601f0e5c..8e62324f7d 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/PlainPasswordFilePrincipalDatabaseTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/database/PlainPasswordFilePrincipalDatabaseTest.java
@@ -22,7 +22,7 @@ package org.apache.qpid.server.security.auth.database;
 
 import junit.framework.TestCase;
 
-import org.apache.qpid.server.security.auth.sasl.UsernamePrincipal;
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
 
 import javax.security.auth.login.AccountNotFoundException;
 import java.io.BufferedReader;
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AnonymousAuthenticationManagerTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AnonymousAuthenticationManagerTest.java
index 9dcd22c088..a36e97199f 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AnonymousAuthenticationManagerTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AnonymousAuthenticationManagerTest.java
@@ -20,6 +20,8 @@
  */
 package org.apache.qpid.server.security.auth.manager;
 
+import static org.apache.qpid.server.security.auth.AuthenticatedPrincipalTestHelper.assertOnlyContainsWrapped;
+
 import javax.security.sasl.SaslException;
 import javax.security.sasl.SaslServer;
 import org.apache.commons.configuration.CompositeConfiguration;
@@ -102,7 +104,8 @@ public class AnonymousAuthenticationManagerTest extends InternalBrokerBaseCase
         assertEquals("Expected authentication to be successful",
                      AuthenticationResult.AuthenticationStatus.SUCCESS,
                      result.getStatus());
-        assertNotNull("Subject should not be null", result.getSubject());
+
+        assertOnlyContainsWrapped(AnonymousAuthenticationManager.ANONYMOUS_PRINCIPAL, result.getPrincipals());
     }
 
 
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AuthenticationManagerRegistryTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AuthenticationManagerRegistryTest.java
index efb8df3a38..9b7131c71a 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AuthenticationManagerRegistryTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/AuthenticationManagerRegistryTest.java
@@ -35,6 +35,8 @@ import org.apache.qpid.server.configuration.ServerConfiguration;
 import org.apache.qpid.server.plugins.Plugin;
 import org.apache.qpid.server.plugins.PluginManager;
 import org.apache.qpid.server.security.SecurityManager.SecurityConfiguration;
+import org.apache.qpid.server.security.SubjectCreator;
+import org.apache.qpid.server.security.group.GroupPrincipalAccessor;
 import org.mockito.Mockito;
 
 import junit.framework.TestCase;
@@ -49,6 +51,8 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
     private List<AuthenticationManager> _allCreatedAuthManagers = new ArrayList<AuthenticationManager>();
 
+    private GroupPrincipalAccessor _groupPrincipalAccessor = mock(GroupPrincipalAccessor.class);;
+
     @Override
     protected void setUp() throws Exception
     {
@@ -76,7 +80,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
         when(_pluginManager.getAuthenticationManagerPlugins()).thenReturn(EMPTY_PLUGINMAP);
         try
         {
-            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -97,7 +101,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         try
         {
-            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -120,7 +124,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         try
         {
-            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -145,7 +149,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         try
         {
-            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -170,7 +174,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         try
         {
-            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+            new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -187,10 +191,10 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         when(_pluginManager.getAuthenticationManagerPlugins()).thenReturn(pluginMap);
 
-        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
 
-        AuthenticationManager authenticationManager = registry.getAuthenticationManager(new InetSocketAddress(1234));
-        assertEquals("TestAuthenticationManager1", authenticationManager.getMechanisms());
+        SubjectCreator subjectCreator = registry.getSubjectCreator(new InetSocketAddress(1234));
+        assertEquals("TestAuthenticationManager1", subjectCreator.getMechanisms());
 
         registry.close();
     }
@@ -202,10 +206,10 @@ public class AuthenticationManagerRegistryTest extends TestCase
 
         when(_pluginManager.getAuthenticationManagerPlugins()).thenReturn(pluginMap);
 
-        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
 
-        AuthenticationManager authenticationManager = registry.getAuthenticationManager(mock(SocketAddress.class));
-        assertEquals("TestAuthenticationManager1", authenticationManager.getMechanisms());
+        SubjectCreator subjectCreator = registry.getSubjectCreator(mock(SocketAddress.class));
+        assertEquals("TestAuthenticationManager1", subjectCreator.getMechanisms());
 
         registry.close();
     }
@@ -225,13 +229,13 @@ public class AuthenticationManagerRegistryTest extends TestCase
         when(_serverConfiguration.getDefaultAuthenticationManager()).thenReturn(defaultAuthManger);
         when(_serverConfiguration.getPortAuthenticationMappings()).thenReturn(Collections.singletonMap(mappedPortNumber, mappedAuthManager));
 
-        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
 
-        AuthenticationManager authenticationManager1 = registry.getAuthenticationManager(new InetSocketAddress(unmappedPortNumber));
-        assertEquals("TestAuthenticationManager1", authenticationManager1.getMechanisms());
+        SubjectCreator subjectCreator = registry.getSubjectCreator(new InetSocketAddress(unmappedPortNumber));
+        assertEquals("TestAuthenticationManager1", subjectCreator.getMechanisms());
 
-        AuthenticationManager authenticationManager2 = registry.getAuthenticationManager(new InetSocketAddress(mappedPortNumber));
-        assertEquals("TestAuthenticationManager2", authenticationManager2.getMechanisms());
+        SubjectCreator subjectCreator2 = registry.getSubjectCreator(new InetSocketAddress(mappedPortNumber));
+        assertEquals("TestAuthenticationManager2", subjectCreator2.getMechanisms());
 
         registry.close();
     }
@@ -246,7 +250,7 @@ public class AuthenticationManagerRegistryTest extends TestCase
         when(_pluginManager.getAuthenticationManagerPlugins()).thenReturn(pluginMap);
         when(_serverConfiguration.getDefaultAuthenticationManager()).thenReturn(defaultAuthManger);
 
-        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager);
+        AuthenticationManagerRegistry registry = new AuthenticationManagerRegistry(_serverConfiguration, _pluginManager, _groupPrincipalAccessor);
 
         registry.close();
     }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/ExternalAuthenticationManagerTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/ExternalAuthenticationManagerTest.java
index c1a55ef2ad..4e0643e229 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/ExternalAuthenticationManagerTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/ExternalAuthenticationManagerTest.java
@@ -18,6 +18,8 @@
  */
 package org.apache.qpid.server.security.auth.manager;
 
+import static org.apache.qpid.server.security.auth.AuthenticatedPrincipalTestHelper.assertOnlyContainsWrapped;
+
 import javax.security.auth.x500.X500Principal;
 import javax.security.sasl.SaslException;
 import javax.security.sasl.SaslServer;
@@ -25,6 +27,7 @@ import org.apache.commons.configuration.CompositeConfiguration;
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.XMLConfiguration;
 import org.apache.qpid.server.configuration.plugins.ConfigurationPlugin;
+
 import org.apache.qpid.server.security.auth.AuthenticationResult;
 import org.apache.qpid.server.security.auth.database.PlainPasswordFilePrincipalDatabase;
 import org.apache.qpid.server.util.InternalBrokerBaseCase;
@@ -103,12 +106,12 @@ public class ExternalAuthenticationManagerTest extends InternalBrokerBaseCase
         assertEquals("Expected authentication to be successful",
                      AuthenticationResult.AuthenticationStatus.SUCCESS,
                      result.getStatus());
-        assertEquals("Expected principal to be unchanged",
-                             principal,
-                             result.getSubject().getPrincipals().iterator().next());
+
+        assertOnlyContainsWrapped(principal, result.getPrincipals());
 
         saslServer = _manager.createSaslServer("EXTERNAL", "example.example.com", null);
         result = _manager.authenticate(saslServer, new byte[0]);
+
         assertNotNull(result);
                 assertEquals("Expected authentication to be unsuccessful",
                              AuthenticationResult.AuthenticationStatus.ERROR,
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/PrincipalDatabaseAuthenticationManagerTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/PrincipalDatabaseAuthenticationManagerTest.java
index 47c189e4fa..391eb4e665 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/PrincipalDatabaseAuthenticationManagerTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/manager/PrincipalDatabaseAuthenticationManagerTest.java
@@ -20,6 +20,8 @@
  */
 package org.apache.qpid.server.security.auth.manager;
 
+import static org.apache.qpid.server.security.auth.AuthenticatedPrincipalTestHelper.assertOnlyContainsWrapped;
+
 import org.apache.commons.configuration.CompositeConfiguration;
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.XMLConfiguration;
@@ -28,10 +30,9 @@ import org.apache.qpid.server.configuration.plugins.ConfigurationPlugin;
 import org.apache.qpid.server.security.auth.AuthenticationResult;
 import org.apache.qpid.server.security.auth.AuthenticationResult.AuthenticationStatus;
 import org.apache.qpid.server.security.auth.database.PlainPasswordFilePrincipalDatabase;
-import org.apache.qpid.server.security.auth.sasl.UsernamePrincipal;
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
 import org.apache.qpid.server.util.InternalBrokerBaseCase;
 
-import javax.security.auth.Subject;
 import javax.security.sasl.SaslException;
 import javax.security.sasl.SaslServer;
 import java.io.BufferedWriter;
@@ -48,6 +49,7 @@ import java.security.Security;
  */
 public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBaseCase
 {
+    private static final UsernamePrincipal PRINCIPAL = new UsernamePrincipal("guest");
     private AuthenticationManager _manager = null; // Class under test
     private String TEST_USERNAME = "guest";
     private String TEST_PASSWORD = "guest";
@@ -72,7 +74,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
     public void setUp() throws Exception
     {
         super.setUp();
-        
+
         final String passwdFilename = createPasswordFile().getCanonicalPath();
         final ConfigurationPlugin config = getConfig(PlainPasswordFilePrincipalDatabase.class.getName(),
                 "passwordFile", passwdFilename);
@@ -121,7 +123,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
     {
         try
         {
-            _manager = PrincipalDatabaseAuthenticationManager.FACTORY.newInstance(getConfig(PlainPasswordFilePrincipalDatabase.class.getName(), "noMethod", "test")); 
+            _manager = PrincipalDatabaseAuthenticationManager.FACTORY.newInstance(getConfig(PlainPasswordFilePrincipalDatabase.class.getName(), "noMethod", "test"));
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -137,7 +139,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
     {
         try
         {
-            _manager = PrincipalDatabaseAuthenticationManager.FACTORY.newInstance(getConfig(PlainPasswordFilePrincipalDatabase.class.getName(), "passwordFile", "/not/found")); 
+            _manager = PrincipalDatabaseAuthenticationManager.FACTORY.newInstance(getConfig(PlainPasswordFilePrincipalDatabase.class.getName(), "passwordFile", "/not/found"));
             fail("Exception not thrown");
         }
         catch (ConfigurationException ce)
@@ -157,7 +159,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
         // relies on those mechanisms attached to PropertiesPrincipalDatabaseManager
         assertEquals("AMQPLAIN PLAIN CRAM-MD5", _manager.getMechanisms());
 
-        Provider qpidProvider = Security.getProvider(PrincipalDatabaseAuthenticationManager.PROVIDER_NAME);
+        Provider qpidProvider = Security.getProvider(AuthenticationManager.PROVIDER_NAME);
         assertNotNull(qpidProvider);
     }
 
@@ -172,49 +174,51 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
         // Merely tests the creation of the mechanism. Mechanisms themselves are tested
         // by their own tests.
     }
-    
+
     /**
      * Tests that the authenticate method correctly interprets an
      * authentication success.
-     * 
+     *
      */
     public void testSaslAuthenticationSuccess() throws Exception
     {
+
         SaslServer testServer = createTestSaslServer(true, false);
-        
+
         AuthenticationResult result = _manager.authenticate(testServer, "12345".getBytes());
-        final Subject subject = result.getSubject();
-        assertTrue(subject.getPrincipals().contains(new UsernamePrincipal("guest")));
+
+        assertOnlyContainsWrapped(PRINCIPAL, result.getPrincipals());
         assertEquals(AuthenticationStatus.SUCCESS, result.getStatus());
     }
 
     /**
-     * 
+     *
      * Tests that the authenticate method correctly interprets an
      * authentication not complete.
-     * 
+     *
      */
     public void testSaslAuthenticationNotCompleted() throws Exception
     {
         SaslServer testServer = createTestSaslServer(false, false);
-        
+
         AuthenticationResult result = _manager.authenticate(testServer, "12345".getBytes());
-        assertNull(result.getSubject());
+        assertEquals("Principals was not expected size", 0, result.getPrincipals().size());
+
         assertEquals(AuthenticationStatus.CONTINUE, result.getStatus());
     }
 
     /**
-     * 
+     *
      * Tests that the authenticate method correctly interprets an
      * authentication error.
-     * 
+     *
      */
     public void testSaslAuthenticationError() throws Exception
     {
         SaslServer testServer = createTestSaslServer(false, true);
-        
+
         AuthenticationResult result = _manager.authenticate(testServer, "12345".getBytes());
-        assertNull(result.getSubject());
+        assertEquals("Principals was not expected size", 0, result.getPrincipals().size());
         assertEquals(AuthenticationStatus.ERROR, result.getStatus());
     }
 
@@ -226,9 +230,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
     public void testNonSaslAuthenticationSuccess() throws Exception
     {
         AuthenticationResult result = _manager.authenticate("guest", "guest");
-        final Subject subject = result.getSubject();
-        assertFalse("Subject should not be set read-only", subject.isReadOnly());
-        assertTrue(subject.getPrincipals().contains(new UsernamePrincipal("guest")));
+        assertOnlyContainsWrapped(PRINCIPAL, result.getPrincipals());
         assertEquals(AuthenticationStatus.SUCCESS, result.getStatus());
     }
 
@@ -240,23 +242,23 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
     public void testNonSaslAuthenticationNotCompleted() throws Exception
     {
         AuthenticationResult result = _manager.authenticate("guest", "wrongpassword");
-        assertNull(result.getSubject());
+        assertEquals("Principals was not expected size", 0, result.getPrincipals().size());
         assertEquals(AuthenticationStatus.CONTINUE, result.getStatus());
     }
-    
+
     /**
      * Tests the ability to de-register the provider.
      */
     public void testClose() throws Exception
     {
         assertEquals("AMQPLAIN PLAIN CRAM-MD5", _manager.getMechanisms());
-        assertNotNull(Security.getProvider(PrincipalDatabaseAuthenticationManager.PROVIDER_NAME));
+        assertNotNull(Security.getProvider(AuthenticationManager.PROVIDER_NAME));
 
         _manager.close();
 
         // Check provider has been removed.
         assertNull(_manager.getMechanisms());
-        assertNull(Security.getProvider(PrincipalDatabaseAuthenticationManager.PROVIDER_NAME));
+        assertNull(Security.getProvider(AuthenticationManager.PROVIDER_NAME));
         _manager = null;
     }
 
@@ -343,7 +345,7 @@ public class PrincipalDatabaseAuthenticationManagerTest extends InternalBrokerBa
             writer = new BufferedWriter(new FileWriter(testFile));
             writer.write(TEST_USERNAME + ":" + TEST_PASSWORD);
             writer.newLine();
- 
+
             return testFile;
 
         }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/rmi/RMIPasswordAuthenticatorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/rmi/RMIPasswordAuthenticatorTest.java
index c0c55de92a..efdb286866 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/rmi/RMIPasswordAuthenticatorTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/rmi/RMIPasswordAuthenticatorTest.java
@@ -20,20 +20,21 @@
  */
 package org.apache.qpid.server.security.auth.rmi;
 
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.InetSocketAddress;
 import java.security.Principal;
+
+import javax.security.auth.Subject;
+
 import junit.framework.TestCase;
 
-import org.apache.qpid.server.configuration.plugins.ConfigurationPlugin;
+import org.apache.qpid.server.security.SubjectCreator;
 import org.apache.qpid.server.security.auth.AuthenticationResult;
 import org.apache.qpid.server.security.auth.AuthenticationResult.AuthenticationStatus;
-import org.apache.qpid.server.security.auth.manager.AuthenticationManager;
-
-import javax.management.remote.JMXPrincipal;
-import javax.security.auth.Subject;
-import javax.security.sasl.SaslException;
-import javax.security.sasl.SaslServer;
-import java.net.InetSocketAddress;
-import java.util.Collections;
+import org.apache.qpid.server.security.auth.SubjectAuthenticationResult;
 
 /**
  * Tests the RMIPasswordAuthenticator and its collaboration with the AuthenticationManager.
@@ -41,6 +42,7 @@ import java.util.Collections;
  */
 public class RMIPasswordAuthenticatorTest extends TestCase
 {
+    private static final Subject SUBJECT = new Subject();
     private final String USERNAME = "guest";
     private final String PASSWORD = "guest";
     private RMIPasswordAuthenticator _rmipa;
@@ -54,23 +56,14 @@ public class RMIPasswordAuthenticatorTest extends TestCase
     }
 
     /**
-     * Tests a successful authentication.  Ensures that a populated read-only subject it returned.
+     * Tests a successful authentication.  Ensures that the expected subject is returned.
      */
     public void testAuthenticationSuccess()
     {
-        final Subject expectedSubject = new Subject(true,
-                Collections.singleton(new JMXPrincipal(USERNAME)),
-                Collections.EMPTY_SET,
-                Collections.EMPTY_SET);
-
-        _rmipa.setAuthenticationManager(createTestAuthenticationManager(true, null));
-
+        _rmipa.setSubjectCreator(createMockSubjectCreator(true, null));
 
         Subject newSubject = _rmipa.authenticate(_credentials);
-        assertTrue("Subject must be readonly", newSubject.isReadOnly());
-        assertTrue("Returned subject does not equal expected value",
-                newSubject.equals(expectedSubject));
-
+        assertSame("Subject must be unchanged", SUBJECT, newSubject);
     }
 
     /**
@@ -78,7 +71,7 @@ public class RMIPasswordAuthenticatorTest extends TestCase
      */
     public void testUsernameOrPasswordInvalid()
     {
-        _rmipa.setAuthenticationManager(createTestAuthenticationManager(false, null));
+        _rmipa.setSubjectCreator(createMockSubjectCreator(false, null));
 
         try
         {
@@ -99,7 +92,7 @@ public class RMIPasswordAuthenticatorTest extends TestCase
     public void testAuthenticationFailure()
     {
         final Exception mockAuthException = new Exception("Mock Auth system failure");
-        _rmipa.setAuthenticationManager(createTestAuthenticationManager(false, mockAuthException));
+        _rmipa.setSubjectCreator(createMockSubjectCreator(false, mockAuthException));
 
         try
         {
@@ -118,7 +111,7 @@ public class RMIPasswordAuthenticatorTest extends TestCase
      */
     public void testNullAuthenticationManager() throws Exception
     {
-        _rmipa.setAuthenticationManager(null);
+        _rmipa.setSubjectCreator(null);
         try
         {
             _rmipa.authenticate(_credentials);
@@ -209,55 +202,30 @@ public class RMIPasswordAuthenticatorTest extends TestCase
         }
     }
 
-    private AuthenticationManager createTestAuthenticationManager(final boolean successfulAuth, final Exception exception)
+    private SubjectCreator createMockSubjectCreator(final boolean successfulAuth, final Exception exception)
     {
-        return new AuthenticationManager()
-        {
-            public void configure(ConfigurationPlugin config)
-            {
-                throw new UnsupportedOperationException();
-            }
+        SubjectCreator subjectCreator = mock(SubjectCreator.class);
 
-            public void initialise()
-            {
-                throw new UnsupportedOperationException();
-            }
+        SubjectAuthenticationResult subjectAuthenticationResult;
 
-            public void close()
-            {
-                throw new UnsupportedOperationException();
-            }
+        if (exception != null) {
 
-            public String getMechanisms()
-            {
-                throw new UnsupportedOperationException();
-            }
-
-            public SaslServer createSaslServer(String mechanism, String localFQDN, Principal externalPrincipal) throws SaslException
-            {
-                throw new UnsupportedOperationException();
-            }
+            subjectAuthenticationResult = new SubjectAuthenticationResult(
+                    new AuthenticationResult(AuthenticationStatus.ERROR, exception));
+        }
+        else if (successfulAuth)
+        {
 
-            public AuthenticationResult authenticate(SaslServer server, byte[] response)
-            {
-                throw new UnsupportedOperationException();
-            }
+            subjectAuthenticationResult = new SubjectAuthenticationResult(
+                    new AuthenticationResult(mock(Principal.class)), SUBJECT);
+        }
+        else
+        {
+            subjectAuthenticationResult = new SubjectAuthenticationResult(new AuthenticationResult(AuthenticationStatus.CONTINUE));
+        }
 
-            public AuthenticationResult authenticate(String username, String password)
-            {
-                if (exception != null) {
-                    return new AuthenticationResult(AuthenticationStatus.ERROR, exception);
-                }
-                else if (successfulAuth)
-                {
-                    return new AuthenticationResult(new Subject());
-                }
-                else
-                {
-                    return new AuthenticationResult(AuthenticationStatus.CONTINUE);
-                }
-            }
+        when(subjectCreator.authenticate(anyString(), anyString())).thenReturn(subjectAuthenticationResult);
 
-        };
+        return subjectCreator;
     }
 }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupDatabaseTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupDatabaseTest.java
new file mode 100644
index 0000000000..b020c1655a
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupDatabaseTest.java
@@ -0,0 +1,456 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.group;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Properties;
+import java.util.Set;
+
+import org.apache.qpid.server.security.group.FileGroupDatabase;
+
+import junit.framework.TestCase;
+
+public class FileGroupDatabaseTest extends TestCase
+{
+    private static final String USER1 = "user1";
+    private static final String USER2 = "user2";
+    private static final String USER3 = "user3";
+
+    private static final String MY_GROUP = "myGroup";
+    private static final String MY_GROUP2 = "myGroup2";
+    private static final String MY_GROUP1 = "myGroup1";
+
+    private FileGroupDatabase _groupDatabase = new FileGroupDatabase();
+    private String _groupFile;
+
+    public void testGetAllGroups() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", USER1);
+
+        Set<String> groups = _groupDatabase.getAllGroups();
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP));
+    }
+
+    public void testGetAllGroupsWhenGroupFileEmpty() throws Exception
+    {
+        _groupDatabase.setGroupFile(_groupFile);
+
+        Set<String> groups = _groupDatabase.getAllGroups();
+        assertEquals(0, groups.size());
+    }
+
+    public void testMissingGroupFile() throws Exception
+    {
+        try
+        {
+            _groupDatabase.setGroupFile("/not/a/file");
+            fail("Exception not thrown");
+        }
+        catch (FileNotFoundException fnfe)
+        {
+            // PASS
+        }
+    }
+
+    public void testInvalidFormat() throws Exception
+    {
+        writeGroupFile("name.notvalid", USER1);
+
+        try
+        {
+            _groupDatabase.setGroupFile(_groupFile);
+            fail("Exception not thrown");
+        }
+        catch (IllegalArgumentException gde)
+        {
+            // PASS
+        }
+    }
+
+    public void testGetUsersInGroup() throws Exception
+    {
+        writeGroupFile("myGroup.users", "user1,user2,user3");
+
+        _groupDatabase.setGroupFile(_groupFile);
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(3, users.size());
+    }
+
+    public void testDuplicateUsersInGroupAreConflated() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user1,user3,user1");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(2, users.size());
+    }
+
+    public void testGetUsersWithEmptyGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertTrue(users.isEmpty());
+    }
+
+    public void testGetUsersInNonExistentGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2,user3");
+
+        Set<String> users = _groupDatabase.getUsersInGroup("groupDoesntExist");
+        assertNotNull(users);
+        assertTrue(users.isEmpty());
+    }
+
+    public void testGetUsersInNullGroup() throws Exception
+    {
+        writeAndSetGroupFile();
+        assertTrue(_groupDatabase.getUsersInGroup(null).isEmpty());
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserBelongsToOneGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP));
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserBelongsToTwoGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup1.users", "user1,user2",
+                             "myGroup2.users", "user1,user3");
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(2, groups.size());
+        assertTrue(groups.contains(MY_GROUP1));
+        assertTrue(groups.contains(MY_GROUP2));
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserAddedToGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup1.users", "user1,user2",
+                             "myGroup2.users", USER2);
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP1));
+
+        _groupDatabase.addUserToGroup(USER1, MY_GROUP2);
+
+        groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(2, groups.size());
+        assertTrue(groups.contains(MY_GROUP1));
+        assertTrue(groups.contains(MY_GROUP2));
+
+        Set<String> users =  _groupDatabase.getUsersInGroup(MY_GROUP2);
+        assertEquals(2, users.size());
+        assertTrue(users.contains(USER1));
+        assertTrue(users.contains(USER2));
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserRemovedFromGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup1.users", "user1,user2",
+                             "myGroup2.users", "user1,user2");
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(2, groups.size());
+        assertTrue(groups.contains(MY_GROUP1));
+        assertTrue(groups.contains(MY_GROUP2));
+
+        _groupDatabase.removeUserFromGroup(USER1, MY_GROUP2);
+
+        groups = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP1));
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserAdddedToGroupTheyAreAlreadyIn() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", USER1);
+        _groupDatabase.addUserToGroup(USER1, MY_GROUP);
+
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER1);
+
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP));
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertEquals(1, users.size());
+        assertTrue(users.contains(USER1));
+    }
+
+    public void testGetGroupPrincipalsForUserWhenUserNotKnown() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+        Set<String> groups = _groupDatabase.getGroupsForUser(USER3);
+        assertEquals(0, groups.size());
+    }
+
+    public void testGetGroupPrincipalsForNullUser() throws Exception
+    {
+        writeAndSetGroupFile();
+        assertTrue(_groupDatabase.getGroupsForUser(null).isEmpty());
+    }
+
+    public void testAddUserToExistingGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(2, users.size());
+
+        _groupDatabase.addUserToGroup(USER3, MY_GROUP);
+
+        users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(3, users.size());
+    }
+
+    public void testAddUserToEmptyGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(0, users.size());
+
+        _groupDatabase.addUserToGroup(USER3, MY_GROUP);
+
+        users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(1, users.size());
+    }
+
+    public void testAddUserToNonExistentGroup() throws Exception
+    {
+        writeAndSetGroupFile();
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(0, users.size());
+
+        try
+        {
+            _groupDatabase.addUserToGroup(USER3, MY_GROUP);
+            fail("Expected exception not thrown");
+        }
+        catch(IllegalArgumentException e)
+        {
+            // pass
+        }
+
+        users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(0, users.size());
+    }
+
+    public void testRemoveUserFromExistingGroup() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(2, users.size());
+
+        _groupDatabase.removeUserFromGroup(USER2, MY_GROUP);
+
+        users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertNotNull(users);
+        assertEquals(1, users.size());
+    }
+
+    public void testRemoveUserFromNonexistentGroup() throws Exception
+    {
+        writeAndSetGroupFile();
+
+        try
+        {
+            _groupDatabase.removeUserFromGroup(USER1, MY_GROUP);
+            fail("Expected exception not thrown");
+        }
+        catch(IllegalArgumentException e)
+        {
+            // pass
+        }
+
+        assertTrue(_groupDatabase.getUsersInGroup(MY_GROUP).isEmpty());
+    }
+
+    public void testRemoveUserFromGroupTwice() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", USER1);
+        assertTrue(_groupDatabase.getUsersInGroup(MY_GROUP).contains(USER1));
+
+        _groupDatabase.removeUserFromGroup(USER1, MY_GROUP);
+        assertTrue(_groupDatabase.getUsersInGroup(MY_GROUP).isEmpty());
+
+        _groupDatabase.removeUserFromGroup(USER1, MY_GROUP);
+        assertTrue(_groupDatabase.getUsersInGroup(MY_GROUP).isEmpty());
+    }
+
+    public void testAddUserPersistedToFile() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertEquals(2, users.size());
+
+        _groupDatabase.addUserToGroup(USER3, MY_GROUP);
+        assertEquals(3, users.size());
+
+        FileGroupDatabase newGroupDatabase = new FileGroupDatabase();
+        newGroupDatabase.setGroupFile(_groupFile);
+
+        Set<String> newUsers = newGroupDatabase.getUsersInGroup(MY_GROUP);
+        assertEquals(users.size(), newUsers.size());
+    }
+
+    public void testRemoveUserPersistedToFile() throws Exception
+    {
+        writeAndSetGroupFile("myGroup.users", "user1,user2");
+
+        Set<String> users = _groupDatabase.getUsersInGroup(MY_GROUP);
+        assertEquals(2, users.size());
+
+        _groupDatabase.removeUserFromGroup(USER2, MY_GROUP);
+        assertEquals(1, users.size());
+
+        FileGroupDatabase newGroupDatabase = new FileGroupDatabase();
+        newGroupDatabase.setGroupFile(_groupFile);
+
+        Set<String> newUsers = newGroupDatabase.getUsersInGroup(MY_GROUP);
+        assertEquals(users.size(), newUsers.size());
+    }
+
+    public void testCreateGroupPersistedToFile() throws Exception
+    {
+        writeAndSetGroupFile();
+
+        Set<String> groups = _groupDatabase.getAllGroups();
+        assertEquals(0, groups.size());
+
+        _groupDatabase.createGroup(MY_GROUP);
+
+        groups = _groupDatabase.getAllGroups();
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP));
+
+        FileGroupDatabase newGroupDatabase = new FileGroupDatabase();
+        newGroupDatabase.setGroupFile(_groupFile);
+
+        Set<String> newGroups = newGroupDatabase.getAllGroups();
+        assertEquals(1, newGroups.size());
+        assertTrue(newGroups.contains(MY_GROUP));
+    }
+
+    public void testRemoveGroupPersistedToFile() throws Exception
+    {
+        writeAndSetGroupFile("myGroup1.users", "user1,user2",
+                             "myGroup2.users", "user1,user2");
+
+        Set<String> groups = _groupDatabase.getAllGroups();
+        assertEquals(2, groups.size());
+
+        Set<String> groupsForUser1 = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(2, groupsForUser1.size());
+
+        _groupDatabase.removeGroup(MY_GROUP1);
+
+        groups = _groupDatabase.getAllGroups();
+        assertEquals(1, groups.size());
+        assertTrue(groups.contains(MY_GROUP2));
+
+        groupsForUser1 = _groupDatabase.getGroupsForUser(USER1);
+        assertEquals(1, groupsForUser1.size());
+
+        FileGroupDatabase newGroupDatabase = new FileGroupDatabase();
+        newGroupDatabase.setGroupFile(_groupFile);
+
+        Set<String> newGroups = newGroupDatabase.getAllGroups();
+        assertEquals(1, newGroups.size());
+        assertTrue(newGroups.contains(MY_GROUP2));
+
+        Set<String> newGroupsForUser1 = newGroupDatabase.getGroupsForUser(USER1);
+        assertEquals(1, newGroupsForUser1.size());
+        assertTrue(newGroupsForUser1.contains(MY_GROUP2));
+}
+
+    @Override
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        _groupFile = createEmptyTestGroupFile();
+    }
+
+    private void writeAndSetGroupFile(String... groupAndUsers) throws Exception
+    {
+        writeGroupFile(groupAndUsers);
+        _groupDatabase.setGroupFile(_groupFile);
+    }
+
+    private void writeGroupFile(String... groupAndUsers) throws Exception
+    {
+        if (groupAndUsers.length % 2 != 0)
+        {
+            throw new IllegalArgumentException("Number of groupAndUsers must be even");
+        }
+
+        Properties props = new Properties();
+        for (int i = 0 ; i < groupAndUsers.length; i=i+2)
+        {
+            String group = groupAndUsers[i];
+            String users = groupAndUsers[i+1];
+            props.put(group, users);
+        }
+
+        props.store(new FileOutputStream(_groupFile), "test group file");
+    }
+
+    private String createEmptyTestGroupFile() throws IOException
+    {
+        File tmpGroupFile = File.createTempFile("groups", "grp");
+        tmpGroupFile.deleteOnExit();
+
+        return tmpGroupFile.getAbsolutePath();
+    }
+
+    @Override
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+
+        if (_groupFile != null)
+        {
+            File groupFile = new File(_groupFile);
+            if (groupFile.exists())
+            {
+                groupFile.delete();
+            }
+        }
+    }
+
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupManagerTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupManagerTest.java
new file mode 100644
index 0000000000..165ecb098f
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/FileGroupManagerTest.java
@@ -0,0 +1,236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.group;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.security.Principal;
+import java.util.Properties;
+import java.util.Set;
+
+import org.apache.commons.configuration.CompositeConfiguration;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.apache.qpid.server.configuration.plugins.ConfigurationPlugin;
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
+import org.apache.qpid.server.util.InternalBrokerBaseCase;
+
+public class FileGroupManagerTest extends InternalBrokerBaseCase
+{
+    private static final String MYGROUP_USERS = "user1";
+    private static final String MY_GROUP = "myGroup.users";
+    private static final String MY_GROUP2 = "myGroup2.users";
+    private File _tmpGroupFile;
+    private FileGroupManager _manager;
+
+    @Override
+    public void tearDown() throws Exception
+    {
+        super.tearDown();
+//TODO: implement closable
+//        if (_manager != null)
+//        {
+//            _manager.close();
+//        }
+
+        if (_tmpGroupFile != null)
+        {
+            if (_tmpGroupFile.exists())
+            {
+                _tmpGroupFile.delete();
+            }
+        }
+    }
+
+    public void testValidGroupFile() throws Exception
+    {
+        final String groupFileName = writeGroupFile();
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+        assertNotNull(_manager);
+    }
+
+    public void testNonExistentGroupFile() throws Exception
+    {
+        final String filePath = "/does.not.exist/";
+        final File fileFile = new File(filePath);
+
+        assertFalse("File already exists", fileFile.exists());
+        final ConfigurationPlugin config = getConfig("groupFile", filePath);
+
+        try
+        {
+            _manager = FileGroupManager.FACTORY.newInstance(config);
+            fail("expected exception was not thrown");
+        }
+        catch(ConfigurationException ce)
+        {
+            assertNotNull(ce.getCause());
+            assertTrue(ce.getCause() instanceof FileNotFoundException);
+        }
+    }
+
+    public void testGetGroupPrincipalsForUser() throws Exception
+    {
+        final String groupFileName = writeGroupFile();
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getGroupPrincipalsForUser("user1");
+        assertEquals(1, principals.size());
+        assertTrue(principals.contains(new GroupPrincipal("myGroup")));
+    }
+
+    public void testGetUserPrincipalsForGroup() throws Exception
+    {
+        final String groupFileName = writeGroupFile();
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getUserPrincipalsForGroup("myGroup");
+        assertEquals(1, principals.size());
+        assertTrue(principals.contains(new UsernamePrincipal("user1")));
+    }
+
+    public void testGetGroupPrincipals() throws Exception
+    {
+        final String groupFileName = writeGroupFile(MY_GROUP, MYGROUP_USERS, MY_GROUP2, MYGROUP_USERS);
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getGroupPrincipals();
+        assertEquals(2, principals.size());
+        assertTrue(principals.contains(new GroupPrincipal("myGroup")));
+        assertTrue(principals.contains(new GroupPrincipal("myGroup2")));
+    }
+
+    public void testCreateGroup() throws Exception
+    {
+        final String groupFileName = writeGroupFile();
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getGroupPrincipals();
+        assertEquals(1, principals.size());
+
+        _manager.createGroup("myGroup2");
+
+        principals = _manager.getGroupPrincipals();
+        assertEquals(2, principals.size());
+        assertTrue(principals.contains(new GroupPrincipal("myGroup2")));
+    }
+
+    public void testRemoveGroup() throws Exception
+    {
+        final String groupFileName = writeGroupFile(MY_GROUP, MYGROUP_USERS);
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getGroupPrincipals();
+        assertEquals(1, principals.size());
+
+        _manager.removeGroup("myGroup");
+
+        principals = _manager.getGroupPrincipals();
+        assertEquals(0, principals.size());
+    }
+
+    public void testAddUserToGroup() throws Exception
+    {
+        final String groupFileName = writeGroupFile(MY_GROUP, MYGROUP_USERS);
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getUserPrincipalsForGroup("myGroup");
+        assertEquals(1, principals.size());
+        assertFalse(principals.contains(new UsernamePrincipal("user2")));
+
+        _manager.addUserToGroup("user2", "myGroup");
+
+        principals = _manager.getUserPrincipalsForGroup("myGroup");
+        assertEquals(2, principals.size());
+        assertTrue(principals.contains(new UsernamePrincipal("user2")));
+    }
+
+    public void testRemoveUserInGroup() throws Exception
+    {
+        final String groupFileName = writeGroupFile(MY_GROUP, MYGROUP_USERS);
+        final ConfigurationPlugin config = getConfig("groupFile", groupFileName);
+        _manager = FileGroupManager.FACTORY.newInstance(config);
+
+        Set<Principal> principals = _manager.getUserPrincipalsForGroup("myGroup");
+        assertEquals(1, principals.size());
+        assertTrue(principals.contains(new UsernamePrincipal("user1")));
+
+        _manager.removeUserFromGroup("user1", "myGroup");
+
+        principals = _manager.getUserPrincipalsForGroup("myGroup");
+        assertEquals(0, principals.size());
+    }
+
+    private ConfigurationPlugin getConfig(final String argName, final String argValue) throws Exception
+    {
+        final ConfigurationPlugin config = new FileGroupManager.FileGroupManagerConfiguration();
+
+        XMLConfiguration xmlconfig = new XMLConfiguration();
+
+        if (argName != null)
+        {
+            xmlconfig.addProperty("file-group-manager.attributes.attribute.name", argName);
+            xmlconfig.addProperty("file-group-manager.attributes.attribute.value", argValue);
+        }
+
+        // Create a CompositeConfiguration as this is what the broker uses
+        CompositeConfiguration composite = new CompositeConfiguration();
+        composite.addConfiguration(xmlconfig);
+        config.setConfiguration("security", xmlconfig);
+        return config;
+    }
+
+    private String writeGroupFile() throws Exception
+    {
+        return writeGroupFile(MY_GROUP, MYGROUP_USERS);
+    }
+
+    private String writeGroupFile(String... groupAndUsers) throws Exception
+    {
+        if (groupAndUsers.length % 2 != 0)
+        {
+            throw new IllegalArgumentException("Number of groupAndUsers must be even");
+        }
+
+        _tmpGroupFile = File.createTempFile("groups", "grp");
+        _tmpGroupFile.deleteOnExit();
+
+        Properties props = new Properties();
+        for (int i = 0 ; i < groupAndUsers.length; i=i+2)
+        {
+            String group = groupAndUsers[i];
+            String users = groupAndUsers[i+1];
+            props.put(group, users);
+        }
+
+        props.store(new FileOutputStream(_tmpGroupFile), "test group file");
+
+        return _tmpGroupFile.getCanonicalPath();
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/GroupPrincipalAccessorTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/GroupPrincipalAccessorTest.java
new file mode 100644
index 0000000000..6f9b73845d
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/GroupPrincipalAccessorTest.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.qpid.server.security.group;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.security.Principal;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.server.security.group.GroupManager;
+import org.apache.qpid.server.security.group.GroupPrincipalAccessor;
+
+public class GroupPrincipalAccessorTest extends TestCase
+{
+    private static final String USERNAME = "username";
+
+    private GroupManager _groupManager1 = mock(GroupManager.class);
+    private GroupManager _groupManager2 = mock(GroupManager.class);
+
+    private Principal _group1 = mock(Principal.class);
+    private Principal _group2 = mock(Principal.class);
+
+    @Override
+    public void setUp()
+    {
+        when(_groupManager1.getGroupPrincipalsForUser(USERNAME)).thenReturn(Collections.singleton(_group1));
+        when(_groupManager2.getGroupPrincipalsForUser(USERNAME)).thenReturn(Collections.singleton(_group2));
+    }
+
+    public void testGetGroupPrincipals()
+    {
+        getAndAssertGroupPrincipals(_group1, _group2);
+    }
+
+    public void testGetGroupPrincipalsWhenAGroupManagerReturnsNull()
+    {
+        when(_groupManager1.getGroupPrincipalsForUser(USERNAME)).thenReturn(null);
+
+        getAndAssertGroupPrincipals(_group2);
+    }
+
+    public void testGetGroupPrincipalsWhenAGroupManagerReturnsEmptySet()
+    {
+        when(_groupManager2.getGroupPrincipalsForUser(USERNAME)).thenReturn(new HashSet<Principal>());
+
+        getAndAssertGroupPrincipals(_group1);
+    }
+
+    private void getAndAssertGroupPrincipals(Principal... expectedGroups)
+    {
+        GroupPrincipalAccessor groupPrincipalAccessor = new GroupPrincipalAccessor(Arrays.asList(_groupManager1, _groupManager2));
+
+        Set<Principal> actualGroupPrincipals = groupPrincipalAccessor.getGroupPrincipals(USERNAME);
+
+        Set<Principal> expectedGroupPrincipals = new HashSet<Principal>(Arrays.asList(expectedGroups));
+
+        assertEquals(expectedGroupPrincipals, actualGroupPrincipals);
+    }
+}
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/GroupPrincipalTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/GroupPrincipalTest.java
index 076b7c9248..d285a0797a 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/security/auth/sasl/GroupPrincipalTest.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/security/group/GroupPrincipalTest.java
@@ -7,9 +7,9 @@
  * to you 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
@@ -18,7 +18,9 @@
  * under the License.
  *
  */
-package org.apache.qpid.server.security.auth.sasl;
+package org.apache.qpid.server.security.group;
+
+import org.apache.qpid.server.security.auth.UsernamePrincipal;
 
 import junit.framework.TestCase;
 
@@ -34,7 +36,7 @@ public class GroupPrincipalTest extends TestCase
     {
         final GroupPrincipal principal = new GroupPrincipal("group");
         final UsernamePrincipal user = new UsernamePrincipal("name");
-        
+
         try
         {
             principal.addMember(user);
@@ -45,7 +47,7 @@ public class GroupPrincipalTest extends TestCase
             // PASS
         }
     }
-    
+
     public void testEqualitySameName()
     {
         final String string = "string";
@@ -80,7 +82,7 @@ public class GroupPrincipalTest extends TestCase
         assertFalse(principal.equals(null));
     }
 
-    
+
 
 
 }
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/util/TestApplicationRegistry.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/util/TestApplicationRegistry.java
index a64ab620ab..411ed81d2a 100644
--- a/qpid/java/broker/src/test/java/org/apache/qpid/server/util/TestApplicationRegistry.java
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/util/TestApplicationRegistry.java
@@ -33,10 +33,12 @@ import org.apache.qpid.server.logging.actors.CurrentActor;
 import org.apache.qpid.server.logging.actors.GenericActor;
 import org.apache.qpid.server.plugins.PluginManager;
 import org.apache.qpid.server.registry.ApplicationRegistry;
+import org.apache.qpid.server.security.SubjectCreator;
 import org.apache.qpid.server.security.auth.database.PropertiesPrincipalDatabase;
 import org.apache.qpid.server.security.auth.manager.AuthenticationManager;
 import org.apache.qpid.server.security.auth.manager.IAuthenticationManagerRegistry;
 import org.apache.qpid.server.security.auth.manager.PrincipalDatabaseAuthenticationManager;
+import org.apache.qpid.server.security.group.GroupPrincipalAccessor;
 
 import java.util.Properties;
 
@@ -58,7 +60,7 @@ public class TestApplicationRegistry extends ApplicationRegistry
 
     @Override
     protected IAuthenticationManagerRegistry createAuthenticationManagerRegistry(
-            ServerConfiguration _configuration, PluginManager _pluginManager)
+            ServerConfiguration configuration, PluginManager pluginManager, final GroupPrincipalAccessor groupPrincipalAccessor)
             throws ConfigurationException
     {
         final Properties users = new Properties();
@@ -98,10 +100,9 @@ public class TestApplicationRegistry extends ApplicationRegistry
             }
 
             @Override
-            public AuthenticationManager getAuthenticationManager(
-                    SocketAddress address)
+            public SubjectCreator getSubjectCreator(SocketAddress address)
             {
-                return pdam;
+                return new SubjectCreator(pdam, groupPrincipalAccessor);
             }
 
             @Override