| /** |
| * 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.felix.useradmin.filestore; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Dictionary; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.felix.useradmin.RoleFactory; |
| import org.osgi.service.useradmin.Group; |
| import org.osgi.service.useradmin.Role; |
| import org.osgi.service.useradmin.User; |
| |
| /** |
| * Test case for {@link RoleRepositorySerializer}. |
| */ |
| public class RoleRepositorySerializerTest extends TestCase { |
| |
| private Role m_userAnyone; |
| private User m_user1; |
| private User m_user2; |
| private User m_user3; |
| private User m_user4; |
| private Group m_group1; |
| private Group m_group2; |
| private Group m_group3; |
| private Map m_repository; |
| |
| private RoleRepositorySerializer m_serializer; |
| |
| /** |
| * Tests that writing and reading a repository with a role, four users and a three group works as expected. |
| */ |
| public void testRWRepositoryWithRolesUsersAndGroupsOk() throws Exception { |
| m_group1.addRequiredMember(m_userAnyone); |
| m_group1.addMember(m_user1); |
| |
| m_group2.addMember(m_group1); |
| m_group2.addMember(m_user2); |
| m_group2.addRequiredMember(m_user1); |
| |
| m_group3.addMember(m_user3); |
| m_group3.addMember(m_user4); |
| m_group3.addRequiredMember(m_userAnyone); |
| |
| addToRepository(m_user1); |
| addToRepository(m_user2); |
| addToRepository(m_user3); |
| addToRepository(m_user4); |
| addToRepository(m_group1); |
| addToRepository(m_group2); |
| addToRepository(m_group3); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(7, result.size()); |
| assertEquals(m_user1, (User) result.get(m_user1.getName())); |
| assertEquals(m_user2, (User) result.get(m_user2.getName())); |
| assertEquals(m_user3, (User) result.get(m_user3.getName())); |
| assertEquals(m_user4, (User) result.get(m_user4.getName())); |
| assertEquals(m_group1, (Group) result.get(m_group1.getName())); |
| assertEquals(m_group2, (Group) result.get(m_group2.getName())); |
| assertEquals(m_group3, (Group) result.get(m_group3.getName())); |
| } |
| |
| /** |
| * Tests that writing and reading a repository with a single group works as expected. |
| */ |
| public void testRWRepositoryWithSingleGroupOk() throws Exception { |
| addToRepository(m_group1); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(1, result.size()); |
| |
| assertEquals(m_group1, (Role) result.get(m_group1.getName())); |
| } |
| |
| /** |
| * Tests that writing and reading a repository without roles works as expected. |
| */ |
| public void testRWRepositoryWithoutRolesOk() throws Exception { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(0, result.size()); |
| } |
| |
| /** |
| * Tests that writing and reading a repository with a single user role works as expected. |
| */ |
| public void testRWRepositoryWithSingleUserOk() throws Exception { |
| addToRepository(m_user1); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(1, result.size()); |
| |
| assertEquals(m_user1, (User) result.get(m_user1.getName())); |
| } |
| |
| /** |
| * Tests that writing and reading a repository with two user roles works as expected. |
| */ |
| public void testRWRepositoryWithTwoUsersOk() throws Exception { |
| addToRepository(m_user1); |
| addToRepository(m_user2); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(2, result.size()); |
| assertEquals(m_user1, (User) result.get(m_user1.getName())); |
| assertEquals(m_user2, (User) result.get(m_user2.getName())); |
| } |
| |
| /** |
| * Tests that reading a repository that has a cyclic group reference can be read ok. |
| */ |
| public void testRWRepositoryWithCyclicGroupReference() throws Exception { |
| m_group1.addMember(m_group2); |
| m_group2.addMember(m_group1); |
| m_group2.addMember(m_user1); |
| |
| addToRepository(m_user1); |
| addToRepository(m_group2); |
| addToRepository(m_group1); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| Map result = m_serializer.deserialize(dis); |
| assertNotNull(result); |
| |
| assertEquals(3, result.size()); |
| assertEquals(m_group1, (Group) result.get(m_group1.getName())); |
| assertEquals(m_group2, (Group) result.get(m_group2.getName())); |
| assertEquals(m_user1, (User) result.get(m_user1.getName())); |
| } |
| |
| /** |
| * Tests that reading a repository that is missing a referenced basic role from a group fails. |
| */ |
| public void testRWRepositoryWithUnreferencedBasicRoleInGroupFail() throws Exception { |
| m_group1.addMember(m_userAnyone); |
| m_group1.addRequiredMember(m_user1); |
| |
| // "Forget" to add the user1 |
| addToRepository(m_group1); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| try { |
| m_serializer.deserialize(dis); |
| |
| fail("IOException expected!"); |
| } catch (IOException e) { |
| // Ok; expected |
| } |
| } |
| |
| /** |
| * Tests that reading a repository that is missing a referenced required role from a group fails. |
| */ |
| public void testRWRepositoryWithUnreferencedRequiredRoleInGroupFail() throws Exception { |
| m_group1.addRequiredMember(m_userAnyone); |
| m_group1.addMember(m_user1); |
| |
| // "Forget" to add the user1! |
| addToRepository(m_group1); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| DataOutputStream dos = new DataOutputStream(baos); |
| |
| m_serializer.serialize(m_repository, dos); // should succeed! |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| DataInputStream dis = new DataInputStream(bais); |
| |
| try { |
| m_serializer.deserialize(dis); |
| |
| fail("IOException expected!"); |
| } catch (IOException e) { |
| // Ok; expected |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| m_serializer = new RoleRepositorySerializer(); |
| |
| m_repository = new HashMap(); |
| |
| m_userAnyone = RoleFactory.createRole(Role.USER_ANYONE); |
| |
| setProperties(m_userAnyone); |
| |
| m_user1 = createUser(1); |
| m_user2 = createUser(2); |
| m_user3 = createUser(3); |
| m_user4 = createUser(4); |
| |
| m_group1 = createGroup(1); |
| m_group2 = createGroup(2); |
| m_group3 = createGroup(3); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| private void addToRepository(Role role) { |
| if (!Role.USER_ANYONE.equals(role.getName())) { |
| m_repository.put(role.getName(), role); |
| } |
| } |
| |
| private void assertEquals(Dictionary expected, Dictionary obtained) { |
| assertNotNull(expected); |
| assertNotNull(obtained); |
| |
| assertEquals(expected.size(), obtained.size()); |
| |
| Enumeration enumeration = expected.keys(); |
| while (enumeration.hasMoreElements()) { |
| Object expectedKey = enumeration.nextElement(); |
| Object expectedValue = expected.get(expectedKey); |
| |
| Object obtainedValue = obtained.get(expectedKey); |
| if (expectedValue == null) { |
| assertNull(obtainedValue); |
| } else if (expectedValue.getClass().isArray()) { |
| assertTrue(Arrays.equals((byte[]) expectedValue, (byte[]) obtainedValue)); |
| } else { |
| assertEquals(expectedValue, obtainedValue); |
| } |
| } |
| } |
| |
| private void assertEquals(Group expected, Group obtained) { |
| assertEquals((Object) expected, (Object) obtained); |
| |
| assertEquals(expected.getProperties(), obtained.getProperties()); |
| assertEquals(expected.getCredentials(), obtained.getCredentials()); |
| assertEquals(expected.getMembers(), obtained.getMembers()); |
| assertEquals(expected.getRequiredMembers(), obtained.getRequiredMembers()); |
| } |
| |
| private void assertEquals(Role expected, Role obtained) { |
| assertEquals((Object) expected, (Object) obtained); |
| |
| assertEquals(expected.getProperties(), obtained.getProperties()); |
| } |
| |
| private void assertEquals(User expected, User obtained) { |
| assertEquals((Object) expected, (Object) obtained); |
| |
| assertEquals(expected.getProperties(), obtained.getProperties()); |
| assertEquals(expected.getCredentials(), obtained.getCredentials()); |
| } |
| |
| private void assertEquals(Role[] expected, Role[] obtained) { |
| if (expected != null) { |
| assertNotNull(obtained); |
| assertEquals(expected.length, obtained.length); |
| |
| List e = new ArrayList(Arrays.asList(expected)); |
| e.removeAll(Arrays.asList(obtained)); |
| |
| assertTrue("Roles not obtained: " + e, e.isEmpty()); |
| |
| Map m = new HashMap(); |
| for (int i = 0; i < expected.length; i++) { |
| m.put(expected[i].getName(), expected[i]); |
| } |
| |
| for (int i = 0; i < obtained.length; i++) { |
| assertEquals(m.get(obtained[i].getName()), obtained[i]); |
| } |
| } else { |
| assertNull(obtained); |
| } |
| } |
| |
| private User createUser(int idx) { |
| String name = "User" + idx; |
| |
| User result = RoleFactory.createUser(name); |
| |
| setCredentials(result); |
| setProperties(result); |
| |
| return result; |
| } |
| |
| private Group createGroup(int idx) { |
| String name = "Group" + idx; |
| |
| Group result = RoleFactory.createGroup(name); |
| |
| setCredentials(result); |
| setProperties(result); |
| |
| return result; |
| } |
| |
| private void setCredentials(User user) { |
| user.getCredentials().put(user.getName(), user.getName()); |
| user.getCredentials().put("password", user.getName()); |
| user.getCredentials().put("certificate", new byte[] { (byte) 0x55, (byte) 0xAA } ); |
| } |
| |
| private void setProperties(Role role) { |
| role.getProperties().put(role.getName(), role.getName()); |
| role.getProperties().put("key1", role.getName()); |
| role.getProperties().put("key2", "hello world".getBytes()); |
| } |
| } |