There are some trouble when i'm running my test under junit. I'm getting this error :
getGroups function works well but the iteration on localGroups throws this error.
@Entity
@Table(name="group", schema="security")
public class SPGroup implements Group {
@Id
@GeneratedValue
@Column(name = "grp_id", unique = true, nullable = false)
private Long id;
@Column(name = "grp_name", unique = true, nullable = false, length=150)
private String name;
@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "group_user", joinColumns = {
@JoinColumn(name = "grp_id", nullable = false, updatable = false) },
inverseJoinColumns = { @JoinColumn(name = "usr_id",
nullable = false, updatable = false) })
private List<SPUser> users = new ArrayList<SPUser>();
@ManyToMany(fetch = FetchType.LAZY, mappedBy = "childGroups")
private List<SPGroup> parentGroups = new ArrayList<SPGroup>();
@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "group_group", joinColumns = {
@JoinColumn(name = "parent_id", nullable = false, updatable = false, referencedColumnName="grp_id") },
inverseJoinColumns = { @JoinColumn(name = "child_id",
nullable = false, updatable = false, referencedColumnName="grp_id") })
private List<SPGroup> childGroups = new ArrayList<SPGroup>();
@OneToMany(fetch = FetchType.LAZY, targetEntity=RoleTag.class ,mappedBy = "group", cascade={CascadeType.ALL})
private List<RoleTag> roleTags = new ArrayList<RoleTag>();
@OneToMany(fetch = FetchType.LAZY, targetEntity=PermissionTag.class, mappedBy = "group", cascade={CascadeType.ALL})
private List<PermissionTag> permissionTags = new ArrayList<PermissionTag>();
...
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Override
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<SPUser> getUsers() {
return users;
}
public void setUsers(List<SPUser> users) {
this.users = users;
}
public void addUser(SPUser user) {
if (user.getGroups() == null) {
user.setGroups(new ArrayList<SPGroup>());
}
if (!user.getGroups().contains(this)) {
user.getGroups().add(this);
}
getUsers().add(user);
}
public List<SPGroup> getParentGroups() {
return parentGroups;
}
public void setParentGroups(List<SPGroup> parentGroups) {
this.parentGroups = parentGroups;
}
public List<SPGroup> getChildGroups() {
return childGroups;
}
public void setChildGroups(List<SPGroup> childGroups) {
this.childGroups = childGroups;
}
public List<RoleTag> getRoleTags() {
return roleTags;
}
public void setRoleTags(List<RoleTag> roleTags) {
this.roleTags = roleTags;
}
public List<PermissionTag> getPermissionTags() {
return permissionTags;
}
public void setPermissionTags(List<PermissionTag> permissionTags) {
this.permissionTags = permissionTags;
}
public void addPermissionTag(PermissionTag permissionTag) {
permissionTag.setGroup(this);
getPermissionTags().add(permissionTag);
}
@Override
public List<SPUser> getAllUsers() {
List<SPUser> allUsers = new ArrayList<SPUser>(getUsers());
for (SPGroup childGroup : getAllChildGroups()) {
for (SPUser user : childGroup.getUsers()) {
if (!allUsers.contains(user)) {
allUsers.add(user);
}
}
}
return allUsers;
}
@Override
public List<SPGroup> getAllParentGroups() {
return getAllParentGroups(new HashSet<SPGroup>(Arrays.asList(this)));
}
private List<SPGroup> getAllParentGroups(Set<SPGroup> ignoreSet) {
List<SPGroup> allparentGroups = new ArrayList<SPGroup>();
for (SPGroup parent : getParentGroups()) {
if (!ignoreSet.contains(parent)) {
ignoreSet.add(parent);
allparentGroups.add(parent);
allparentGroups.addAll(parent.getAllParentGroups(ignoreSet));
}
}
return allparentGroups;
}
@Override
public List<SPGroup> getAllChildGroups() {
return getAllChildGroups(new HashSet<SPGroup>(Arrays.asList(this)));
}
private List<SPGroup> getAllChildGroups(Set<SPGroup> ignoreSet) {
List<SPGroup> allChildrenGroups = new ArrayList<SPGroup>();
for (SPGroup child : getChildGroups()) {
if (!ignoreSet.contains(child)) {
ignoreSet.add(child);
allChildrenGroups.add(child);
allChildrenGroups.addAll(child.getAllChildGroups(ignoreSet));
}
}
return allChildrenGroups;
}
@Override
public Set<Role> getRoles() {
return getRoles(true);
}
private Set<Role> getRoles(boolean merged) {
if (merged) {
return getActiveRoles(getMergedRoleMap());
} else {
return getActiveRoles(getRoleMap());
}
}
private Map<Role, Boolean> getRoleMap() {
Map<Role, Boolean> roleMap = new HashMap<Role, Boolean>();
for (RoleTag roleTag : getRoleTags()) {
roleMap.put(roleTag.getRole(), roleTag.isGranting());
}
return roleMap;
}
private Map<Role, Boolean> getParentsRoleMap() {
return mergeRolesFromGroups(getParentGroups());
}
private Map<Role, Boolean> getMergedRoleMap() {
Map<Role, Boolean> roleMap = getRoleMap();
for (Entry<Role, Boolean> mergedEntry : getParentsRoleMap().entrySet()) {
// the roleMap override all the parents directives
if (!roleMap.containsKey(mergedEntry.getKey())) {
roleMap.put(mergedEntry.getKey(), mergedEntry.getValue());
}
}
return roleMap;
}
private static Map<Role, Boolean> mergeRolesFromGroups(List<SPGroup> groups) {
Map<Role, Boolean> mergedRoleMap = new HashMap<Role, Boolean>();
// merge of the parents' role
for (SPGroup group : groups) {
for (Entry<Role, Boolean> roleMapEntry : group.getMergedRoleMap().entrySet()) {
if (mergedRoleMap.containsKey(roleMapEntry.getKey())) {
// We apply a OR operation between the parents' role
if (roleMapEntry.getValue() && !mergedRoleMap.get(roleMapEntry.getKey())) {
mergedRoleMap.put(roleMapEntry.getKey(), roleMapEntry.getValue());
}
} else {
mergedRoleMap.put(roleMapEntry.getKey(), roleMapEntry.getValue());
}
}
}
return mergedRoleMap;
}
private static Set<Role> getActiveRoles(Map<Role, Boolean> roleMap) {
Set<Role> roles = new HashSet<Role>();
for (Entry<Role, Boolean> mapEntry : roleMap.entrySet()) {
if (mapEntry.getValue()) {
roles.add(mapEntry.getKey());
}
}
return roles;
}
private Map<SPPermission, SPPerimeter> getPermissionMap() {
Map<SPPermission, SPPerimeter> permissionMap = new HashMap<SPPermission, SPPerimeter>();
for (PermissionTag permissionTag : getPermissionTags()) {
if (!permissionMap.containsKey(permissionTag.getPermission())) {
permissionMap.put(permissionTag.getPermission(), new SPPerimeter());
}
permissionMap.get(permissionTag.getPermission()).add(permissionTag);
}
return permissionMap;
}
private Map<SPPermission, SPPerimeter> getParentsPermissionMap() {
return mergePermissionsFromGroups(getParentGroups());
}
public Map<SPPermission, SPPerimeter> getMergedPermissionMap() {
Map<SPPermission, SPPerimeter> permissionMap = getPermissionMap();
for (Entry<SPPermission, SPPerimeter> entry : getParentsPermissionMap().entrySet()) {
if (permissionMap.containsKey(entry.getKey())) {
permissionMap.get(entry.getKey()).merge(entry.getValue());
} else {
permissionMap.put(entry.getKey(), entry.getValue());
}
}
return permissionMap;
}
public static Map<SPPermission, SPPerimeter> mergePermissionsFromGroups(List<SPGroup> groups) {
Map<SPPermission, SPPerimeter> permissionMap = new HashMap<SPPermission, SPPerimeter>();
for (SPGroup group : groups) {
for (Entry<SPPermission, SPPerimeter> entry : group.getMergedPermissionMap().entrySet()) {
if (permissionMap.containsKey(entry.getKey())) {
permissionMap.get(entry.getKey()).add(entry.getValue());
} else {
permissionMap.put(entry.getKey(), entry.getValue());
}
}
}
return permissionMap;
}
@Override
public Map<SPPermission, SPPerimeter> getPermissions() {
return getMergedPermissionMap();
}
@Override
public String toString() {
return getName() + "[" + getId() + "]";
}
@Override
public void setRole(GrantedAuthority role, boolean granting) {
if (role instanceof Role) {
setRole((Role) role, granting);
} else {
setRole(new Role(role.getAuthority()), granting);
}
}
@Override
public void setPermission(Permission permission, Perimeter perimeter) {
if (permission instanceof SPPermission) {
setPermission((SPPermission) permission, perimeter);
} else {
setPermission(new SPPermission(permission.getObjectType(), permission.getAction()), perimeter);
}
}
private void setRole(Role role, boolean granting) {
Map<Role, Boolean> roleMap = getMergedRoleMap();
if (granting) {
if (!roleMap.containsKey(role)) {
// Role not defined
getRoleTags().add(new RoleTag(role, true));
} else if (!roleMap.get(role)) {
// Role explicitly forbidden
Iterator<RoleTag> iterator = getRoleTags().iterator();
while (iterator.hasNext()) {
RoleTag current = iterator.next();
if (current.getRole().equals(role)) {
iterator.remove();
}
}
getRoleTags().add(new RoleTag(role, true));
}
} else {
if (roleMap.containsKey(role) && roleMap.get(role)) {
// Role present
Iterator<RoleTag> iterator = getRoleTags().iterator();
boolean removed = false;
while (iterator.hasNext()) {
RoleTag current = iterator.next();
if (current.getRole().equals(role)) {
iterator.remove();
removed = true;
}
}
if (removed) {
// Role was present locally, check inheritance again
roleMap = getMergedRoleMap();
if (roleMap.containsKey(role) && roleMap.get(role)) {
// Role still present, explicit remove
getRoleTags().add(new RoleTag(role, false));
}
} else {
// Role was not present locally, explicit remove
getRoleTags().add(new RoleTag(role, false));
}
}
}
}
private boolean clearLocalPermission(SPPermission permission) {
Iterator<PermissionTag> iterator = getPermissionTags().iterator();
boolean modified = false;
while (iterator.hasNext()) {
PermissionTag permissionTag = iterator.next();
if (permissionTag.getPermission().equals(permission)) {
iterator.remove();
modified = true;
}
}
return modified;
}
private void addLimitedPermisisonTags(SPPermission permission, Perimeter perimeter, Perimeter inheritedPerimeter) throws IllegalArgumentException {
boolean isInherited = inheritedPerimeter != null;
if (perimeter.isMyAllowed()) {
if (!isInherited || !inheritedPerimeter.isMyAllowed()) {
addPermissionTag(new PermissionTag(permission, Type.MY));
}
}
for (Group group : perimeter.getAllowedGroups()) {
if (group instanceof SPGroup) {
if (!isInherited || !inheritedPerimeter.getAllowedGroups().contains(group)) {
addPermissionTag(new PermissionTag(permission, (SPGroup) group));
}
} else {
throw new IllegalArgumentException("Groups in perimeter must be an instance of com.sample.security.metier.impl.SPGroup");
}
}
for (User user : perimeter.getAllowedUsers()) {
if (user instanceof SPUser) {
if (!isInherited || !inheritedPerimeter.getAllowedUsers().contains(user)) {
addPermissionTag(new PermissionTag(permission, (SPUser) user));
}
} else {
throw new IllegalArgumentException("Users in perimeter must be an instance of com.sample.security.metier.impl.SPUser");
}
}
}
private void setPermission(SPPermission permission, Perimeter perimeter) {
Map<SPPermission, SPPerimeter> permissions = getPermissions();
if (permissions.containsKey(permission)) {
// Permission already defined
switch (perimeter.getType()) {
case ALL:
if (permissions.get(permission).getType() != PerimeterType.ALL) {
if (clearLocalPermission(permission)) {
// Local permissions have been modified
permissions = getPermissions();
if (permissions.containsKey(permission) && permissions.get(permission).getType() != PerimeterType.ALL) {
// No inherited ALL permission, local definition
addPermissionTag(new PermissionTag(permission, Type.ALL));
}
} else {
// Permission was not present locally
addPermissionTag(new PermissionTag(permission, Type.ALL));
}
}
break;
case LIMITED:
if (clearLocalPermission(permission)) {
permissions = getPermissions();
}
if (permissions.containsKey(permission) && permissions.get(permission).getType() != PerimeterType.LIMITED) {
SPPerimeter inheritedPerimeter = permissions.get(permission);
addLimitedPermisisonTags(permission, perimeter, inheritedPerimeter);
} else {
// Wrong inherited permission, local override
addLimitedPermisisonTags(permission, perimeter, null);
}
break;
case EMPTY:
if (permissions.get(permission).getType() != PerimeterType.EMPTY) {
if (clearLocalPermission(permission)) {
// Local permissions have been modified
permissions = getPermissions();
if (permissions.containsKey(permission) && permissions.get(permission).getType() != PerimeterType.EMPTY) {
// Permission still inherited, local override
addPermissionTag(new PermissionTag(permission, Type.NO));
}
} else {
// Permission was inherited, local override
addPermissionTag(new PermissionTag(permission, Type.NO));
}
}
break;
}
} else {
// New permission for this group
switch (perimeter.getType()) {
case ALL:
addPermissionTag(new PermissionTag(permission, Type.ALL));
break;
case LIMITED:
addLimitedPermisisonTags(permission, perimeter, null);
break;
default:
// No modifications
break;
}
}
}
...
}
CREATE schema security AUTHORIZATION DBA;--déclaration du schema et des droits pour HSQL
CREATE TABLE security.group (grp_id BIGINT GENERATED BY DEFAULT AS IDENTITY (START WITH 1 INCREMENT BY 1) NOT NULL, grp_name VARCHAR(150) NOT NULL, PRIMARY KEY (grp_id));
REATE TABLE security.user (usr_id BIGINT GENERATED BY DEFAULT AS IDENTITY (START WITH 1 INCREMENT BY 1) NOT NULL, usr_creation TIMESTAMP, usr_email VARCHAR(128), usr_enabled BOOLEAN NOT NULL, usr_expiration TIMESTAMP, usr_firstname VARCHAR(50), usr_lastname VARCHAR(50), usr_modification TIMESTAMP, usr_password VARCHAR(100) NOT NULL, usr_login VARCHAR(128) NOT NULL, PRIMARY KEY (usr_id));
CREATE TABLE security.group_user (grp_id BIGINT NOT NULL, usr_id BIGINT NOT NULL, PRIMARY KEY (grp_id, usr_id));
ALTER TABLE security.group ADD CONSTRAINT UNQ_group_1 UNIQUE (grp_name);
ALTER TABLE security.user ADD CONSTRAINT UNQ_user_2 UNIQUE (usr_email);
ALTER TABLE security.user ADD CONSTRAINT UNQ_user_9 UNIQUE (usr_login);
ALTER TABLE security.group_user ADD CONSTRAINT FK_group_user_usr_id FOREIGN KEY (usr_id) REFERENCES security.user (usr_id);
ALTER TABLE security.group_user ADD CONSTRAINT FK_group_user_grp_id FOREIGN KEY (grp_id) REFERENCES security.group (grp_id);
If I enable generation of the schema, delete all definition from SQL script and generating data with this part of code inside my test function, it works. What's the difference?
SPUser userToRegister = new SPUser("commercial.63-1","","commercial.63-1@sample.com",true);
List<SPGroup> listGroup = new ArrayList<SPGroup>();
List<SPUser> listUser = new ArrayList<SPUser>();
SPGroup groupToRegister = new SPGroup("Commercial 63");
listUser.add(userToRegister);
groupToRegister.setUsers(listUser);
listGroup.add(groupToRegister);
userToRegister.setGroups(listGroup);
userRepository.save(userToRegister);
groupRepository.save(groupToRegister);
Login
FAQ
Search