/**
* 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.impl;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import junit.framework.TestCase;
import org.apache.felix.useradmin.RoleRepositoryStore;
import org.osgi.framework.Filter;
import org.osgi.framework.FrameworkUtil;
import org.osgi.service.useradmin.Group;
import org.osgi.service.useradmin.Role;
import org.osgi.service.useradmin.User;
/**
* Tests whether using custom roles in the backend work as expected and yield the proper events.
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class CustomRoleImplTest extends TestCase
{
static class MyGroupImpl extends MyUserImpl implements Group {
private final Map m_members;
private final Map m_requiredMembers;
public MyGroupImpl(String name) {
super(name, GROUP);
m_members = new HashMap();
m_requiredMembers = new HashMap();
}
public boolean addMember(Role role) {
String name = role.getName();
if (m_requiredMembers.containsKey(name) || m_members.containsKey(name)) {
return false;
}
return m_members.put(name, role) == null;
}
public boolean addRequiredMember(Role role) {
String name = role.getName();
if (m_requiredMembers.containsKey(name) || m_members.containsKey(name)) {
return false;
}
return m_requiredMembers.put(name, role) == null;
}
public Role[] getMembers() {
Role[] result = new Role[m_members.size()];
return (Role[]) m_members.values().toArray(result);
}
public Role[] getRequiredMembers() {
Role[] result = new Role[m_requiredMembers.size()];
return (Role[]) m_requiredMembers.values().toArray(result);
}
public boolean removeMember(Role role) {
String name = role.getName();
if (m_requiredMembers.remove(name) != null) {
return true;
} else if (m_members.remove(name) != null) {
return true;
}
return false;
}
}
static class MyRoleImpl implements Role {
private final String m_name;
private final int m_type;
private final Hashtable m_props;
public MyRoleImpl(String name, int type) {
m_name = name;
m_type = type;
m_props = new Hashtable();
}
public String getName() {
return m_name;
}
public Dictionary getProperties() {
return m_props;
}
public int getType() {
return m_type;
}
}
static class MyRoleRepositoryStore implements RoleRepositoryStore {
private final ConcurrentMap m_entries = new ConcurrentHashMap();
public Role addRole(String roleName, int type) throws IOException {
if (roleName == null) {
throw new IllegalArgumentException("Name cannot be null!");
}
Role role = createRole(roleName, type);
Object result = m_entries.putIfAbsent(roleName, role);
return (result == null) ? role : null;
}
public Role getRoleByName(String roleName) throws Exception {
if (roleName == null) {
throw new IllegalArgumentException("Role name cannot be null!");
}
return (Role) m_entries.get(roleName);
}
public Role[] getRoles(String filterValue) throws Exception {
Collection roles = m_entries.values();
Filter filter = null;
if (filterValue != null) {
filter = FrameworkUtil.createFilter(filterValue);
}
List matchingRoles = new ArrayList();
Iterator rolesIter = roles.iterator();
while (rolesIter.hasNext()) {
Role role = (Role) rolesIter.next();
if ((filter == null) || filter.match(role.getProperties())) {
matchingRoles.add(role);
}
}
Role[] result = new Role[matchingRoles.size()];
return (Role[]) matchingRoles.toArray(result);
}
public Role removeRole(String roleName) throws Exception {
if (roleName == null) {
throw new IllegalArgumentException("Name cannot be null!");
}
Role role = getRoleByName(roleName);
boolean result = m_entries.remove(roleName, role);
return result ? role : null;
}
private Role createRole(String roleName, int type) {
Role role;
if (type == Role.USER) {
role = new MyUserImpl(roleName);
} else if (type == Role.GROUP) {
role = new MyGroupImpl(roleName);
} else {
throw new IllegalArgumentException("Invalid role type!");
}
return role;
}
}
static class MyUserImpl extends MyRoleImpl implements User {
private final Hashtable m_creds;
public MyUserImpl(String name) {
this(name, USER);
}
protected MyUserImpl(String name, int type) {
super(name, type);
m_creds = new Hashtable();
}
public Dictionary getCredentials() {
return m_creds;
}
public boolean hasCredential(String key, Object value) {
if (m_creds.containsKey(key)) {
Object v = m_creds.get(key);
return ((v == value) || ((v != null) && v.equals(value)));
}
return false;
}
}
private CountDownLatch m_latch;
private RoleRepository m_repository;
/**
* Tests that adding a basic member to a group-role yields an event.
*/
public void testAddBasicGroupMemberYieldsEvent() throws Exception {
final Group role = (Group) m_repository.addRole("testGroup", Role.GROUP);
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
Role anyone = m_repository.getRoleByName(Role.USER_ANYONE);
assertTrue(role.addMember(anyone));
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that adding an existing role does not yield an event.
*/
public void testAddExistingRoleDoesNotYieldEvent() throws Exception {
assertNotNull(m_repository.addRole("testUser", Role.USER));
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
assertNull(m_repository.addRole("testUser", Role.USER));
};
}).start();
assertFalse(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that adding a new role yields an event.
*/
public void testAddNewRoleYieldsEvent() throws Exception {
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
assertNotNull(m_repository.addRole("testUser", Role.USER));
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that adding a required member to a group-role yields an event.
*/
public void testAddRequiredGroupMemberYieldsEvent() throws Exception {
final Group role = (Group) m_repository.addRole("testGroup", Role.GROUP);
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
Role anyone = m_repository.getRoleByName(Role.USER_ANYONE);
assertTrue(role.addRequiredMember(anyone));
};
}).start();
assertTrue(m_latch.await(100, TimeUnit.SECONDS));
}
/**
* Tests that changing the properties of a user-role yields an event.
*/
public void testAddRolePropertiesYieldsEvent() throws Exception {
final Role role = m_repository.addRole("testUser", Role.USER);
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getProperties().put("key", "value");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that changing the credentials of a user-role yields an event.
*/
public void testAddUserCredentialsYieldsEvent() throws Exception {
final User role = (User) m_repository.addRole("testUser", Role.USER);
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getCredentials().put("key", "value");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that changing the credentials of a user-role yields an event.
*/
public void testChangePropertiesYieldsEvent() throws Exception {
final Role role = m_repository.addRole("testUser", Role.USER);
role.getProperties().put("key", "value1");
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getProperties().put("key", "value2");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that changing the credentials of a user-role yields an event.
*/
public void testChangeUserCredentialsYieldsEvent() throws Exception {
final User role = (User) m_repository.addRole("testUser", Role.USER);
role.getCredentials().put("key", "value1");
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getCredentials().put("key", "value2");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that removing an existing role does yield an event.
*/
public void testRemoveExistingRoleYieldsEvent() throws Exception {
assertNotNull(m_repository.addRole("testUser", Role.USER));
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
assertTrue(m_repository.removeRole("testUser"));
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that removing a non-existing role does not yield an event.
*/
public void testRemoveNonExistingRoleDoesNotYieldEvent() throws Exception {
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
assertFalse(m_repository.removeRole("testUser"));
};
}).start();
assertFalse(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that changing the properties of a user-role yields an event.
*/
public void testRemoveRolePropertiesYieldsEvent() throws Exception {
final Role role = m_repository.addRole("testUser", Role.USER);
role.getProperties().put("key", "value");
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getProperties().remove("key");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that changing the credentials of a user-role yields an event.
*/
public void testRemoveUserCredentialsYieldsEvent() throws Exception {
final User role = (User) m_repository.addRole("testUser", Role.USER);
role.getCredentials().put("key", "value");
assertNotNull(role);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
role.getCredentials().remove("key");
};
}).start();
assertTrue(m_latch.await(1, TimeUnit.SECONDS));
}
/**
* Tests that removing a member from a group-role yields an event.
*/
public void testRemovingGroupMemberYieldsEvent() throws Exception {
final Role anyone = m_repository.getRoleByName(Role.USER_ANYONE);
final Group role = (Group) m_repository.addRole("testGroup", Role.GROUP);
assertNotNull(role);
role.addRequiredMember(anyone);
m_latch = new CountDownLatch(1);
new Thread(new Runnable() {
public void run() {
assertTrue(role.removeMember(anyone));
};
}).start();
assertTrue(m_latch.await(100, TimeUnit.SECONDS));
}
/**
* Set up for all test cases.
*/
protected void setUp() throws Exception
{
m_repository = new RoleRepository(new MyRoleRepositoryStore());
m_repository.addRoleChangeListener(new RoleChangeListener() {
public void propertyAdded(Role role, Object key, Object value) {
if (m_latch != null) {
m_latch.countDown();
}
}
public void propertyChanged(Role role, Object key, Object oldValue, Object newValue) {
if (m_latch != null) {
m_latch.countDown();
}
}
public void propertyRemoved(Role role, Object key) {
if (m_latch != null) {
m_latch.countDown();
}
}
public void roleAdded(Role role) {
if (m_latch != null) {
m_latch.countDown();
}
}
public void roleRemoved(Role role) {
if (m_latch != null) {
m_latch.countDown();
}
}
});
}
}