You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@syncope.apache.org by il...@apache.org on 2015/04/21 11:33:32 UTC
[03/57] syncope git commit: [SYNCOPE-119] Renaming Role to Group
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AbstractITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AbstractITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AbstractITCase.java
index 0f0560a..fc4af36 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AbstractITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AbstractITCase.java
@@ -22,7 +22,6 @@ import static org.junit.Assert.assertNotNull;
import java.io.InputStream;
import java.net.URI;
-import java.util.Hashtable;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
@@ -37,13 +36,13 @@ import org.apache.cxf.jaxrs.client.WebClient;
import org.apache.syncope.client.lib.SyncopeClient;
import org.apache.syncope.client.lib.SyncopeClientFactoryBean;
import org.apache.syncope.common.lib.mod.AttrMod;
-import org.apache.syncope.common.lib.mod.RoleMod;
+import org.apache.syncope.common.lib.mod.GroupMod;
import org.apache.syncope.common.lib.mod.UserMod;
import org.apache.syncope.common.lib.to.AbstractPolicyTO;
import org.apache.syncope.common.lib.to.AbstractSchemaTO;
import org.apache.syncope.common.lib.to.AttrTO;
import org.apache.syncope.common.lib.to.ResourceTO;
-import org.apache.syncope.common.lib.to.RoleTO;
+import org.apache.syncope.common.lib.to.GroupTO;
import org.apache.syncope.common.lib.to.UserTO;
import org.apache.syncope.common.lib.types.AttributableType;
import org.apache.syncope.common.lib.types.ConnConfProperty;
@@ -58,7 +57,7 @@ import org.apache.syncope.common.rest.api.service.NotificationService;
import org.apache.syncope.common.rest.api.service.PolicyService;
import org.apache.syncope.common.rest.api.service.ReportService;
import org.apache.syncope.common.rest.api.service.ResourceService;
-import org.apache.syncope.common.rest.api.service.RoleService;
+import org.apache.syncope.common.rest.api.service.GroupService;
import org.apache.syncope.common.rest.api.service.SchemaService;
import org.apache.syncope.common.rest.api.service.SecurityQuestionService;
import org.apache.syncope.common.rest.api.service.SyncopeService;
@@ -153,7 +152,7 @@ public abstract class AbstractITCase {
protected static UserWorkflowService userWorkflowService;
- protected static RoleService roleService;
+ protected static GroupService groupService;
protected static ResourceService resourceService;
@@ -178,7 +177,7 @@ public abstract class AbstractITCase {
protected static PolicyService policyService;
protected static SecurityQuestionService securityQuestionService;
-
+
protected static CamelRouteService camelRouteService;
@Autowired
@@ -218,7 +217,7 @@ public abstract class AbstractITCase {
userService = adminClient.getService(UserService.class);
userSelfService = adminClient.getService(UserSelfService.class);
userWorkflowService = adminClient.getService(UserWorkflowService.class);
- roleService = adminClient.getService(RoleService.class);
+ groupService = adminClient.getService(GroupService.class);
resourceService = adminClient.getService(ResourceService.class);
entitlementService = adminClient.getService(EntitlementService.class);
configurationService = adminClient.getService(ConfigurationService.class);
@@ -302,23 +301,23 @@ public abstract class AbstractITCase {
return (T) getObject(response.getLocation(), SchemaService.class, schemaTO.getClass());
}
- protected RoleTO createRole(final RoleTO newRoleTO) {
- Response response = roleService.create(newRoleTO);
+ protected GroupTO createGroup(final GroupTO newGroupTO) {
+ Response response = groupService.create(newGroupTO);
if (response.getStatusInfo().getStatusCode() != Response.Status.CREATED.getStatusCode()) {
Exception ex = clientFactory.getExceptionMapper().fromResponse(response);
if (ex != null) {
throw (RuntimeException) ex;
}
}
- return getObject(response.getLocation(), RoleService.class, RoleTO.class);
+ return getObject(response.getLocation(), GroupService.class, GroupTO.class);
}
- protected RoleTO updateRole(final RoleMod roleMod) {
- return roleService.update(roleMod.getKey(), roleMod).readEntity(RoleTO.class);
+ protected GroupTO updateGroup(final GroupMod groupMod) {
+ return groupService.update(groupMod.getKey(), groupMod).readEntity(GroupTO.class);
}
- protected RoleTO deleteRole(final Long id) {
- return roleService.delete(id).readEntity(RoleTO.class);
+ protected GroupTO deleteGroup(final Long id) {
+ return groupService.delete(id).readEntity(GroupTO.class);
}
@SuppressWarnings("unchecked")
@@ -351,7 +350,7 @@ public abstract class AbstractITCase {
final Map<String, ConnConfProperty> ldapConnConf =
connectorService.read(ldapRes.getConnectorId()).getConfigurationMap();
- Hashtable env = new Hashtable();
+ Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://" + ldapConnConf.get("host").getValues().get(0)
+ ":" + ldapConnConf.get("port").getValues().get(0) + "/");
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ActivitiDetector.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ActivitiDetector.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ActivitiDetector.java
index f697c19..798a313 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ActivitiDetector.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ActivitiDetector.java
@@ -26,7 +26,7 @@ public class ActivitiDetector {
return syncopeService.info().getUserWorkflowAdapter().indexOf("Activiti") != -1;
}
- public static boolean isActivitiEnabledForRoles(final SyncopeService syncopeService) {
- return syncopeService.info().getRoleWorkflowAdapter().indexOf("Activiti") != -1;
+ public static boolean isActivitiEnabledForGroups(final SyncopeService syncopeService) {
+ return syncopeService.info().getGroupWorkflowAdapter().indexOf("Activiti") != -1;
}
}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
index 4623f25..ef99feb 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
@@ -40,7 +40,7 @@ import org.apache.syncope.common.lib.to.BulkActionResult;
import org.apache.syncope.common.lib.to.MembershipTO;
import org.apache.syncope.common.lib.to.PagedResult;
import org.apache.syncope.common.lib.to.PlainSchemaTO;
-import org.apache.syncope.common.lib.to.RoleTO;
+import org.apache.syncope.common.lib.to.GroupTO;
import org.apache.syncope.common.lib.to.UserTO;
import org.apache.syncope.common.lib.to.WorkflowFormPropertyTO;
import org.apache.syncope.common.lib.to.WorkflowFormTO;
@@ -99,14 +99,14 @@ public class AuthenticationITCase extends AbstractITCase {
@Test
public void testUserSchemaAuthorization() {
- // 0. create a role that can only read schemas
- RoleTO authRoleTO = new RoleTO();
- authRoleTO.setName("authRole" + getUUIDString());
- authRoleTO.setParent(8L);
- authRoleTO.getEntitlements().add("SCHEMA_READ");
+ // 0. create a group that can only read schemas
+ GroupTO authGroupTO = new GroupTO();
+ authGroupTO.setName("authGroup" + getUUIDString());
+ authGroupTO.setParent(8L);
+ authGroupTO.getEntitlements().add("SCHEMA_READ");
- authRoleTO = createRole(authRoleTO);
- assertNotNull(authRoleTO);
+ authGroupTO = createGroup(authGroupTO);
+ assertNotNull(authGroupTO);
String schemaName = "authTestSchema" + getUUIDString();
@@ -119,11 +119,11 @@ public class AuthenticationITCase extends AbstractITCase {
PlainSchemaTO newPlainSchemaTO = createSchema(AttributableType.USER, SchemaType.PLAIN, schemaTO);
assertEquals(schemaTO, newPlainSchemaTO);
- // 2. create an user with the role created above (as admin)
+ // 2. create an user with the group created above (as admin)
UserTO userTO = UserITCase.getUniqueSampleTO("auth@test.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(authRoleTO.getKey());
+ membershipTO.setGroupId(authGroupTO.getKey());
AttrTO testAttrTO = new AttrTO();
testAttrTO.setSchema("testAttribute");
testAttrTO.getValues().add("a value");
@@ -146,7 +146,7 @@ public class AuthenticationITCase extends AbstractITCase {
// 5. update the schema create above (as user) - failure
try {
- schemaService2.update(AttributableType.ROLE, SchemaType.PLAIN, schemaName, schemaTO);
+ schemaService2.update(AttributableType.GROUP, SchemaType.PLAIN, schemaName, schemaTO);
fail("Schemaupdate as user schould not work");
} catch (SyncopeClientException e) {
assertNotNull(e);
@@ -164,7 +164,7 @@ public class AuthenticationITCase extends AbstractITCase {
UserTO userTO = UserITCase.getUniqueSampleTO("testuserread@test.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(7L);
+ membershipTO.setGroupId(7L);
AttrTO testAttrTO = new AttrTO();
testAttrTO.setSchema("testAttribute");
testAttrTO.getValues().add("a value");
@@ -190,7 +190,7 @@ public class AuthenticationITCase extends AbstractITCase {
exception = e;
}
assertNotNull(exception);
- assertEquals(ClientExceptionType.UnauthorizedRole, exception.getType());
+ assertEquals(ClientExceptionType.UnauthorizedGroup, exception.getType());
}
@Test
@@ -198,7 +198,7 @@ public class AuthenticationITCase extends AbstractITCase {
UserTO userTO = UserITCase.getUniqueSampleTO("testusersearch@test.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(7L);
+ membershipTO.setGroupId(7L);
AttrTO testAttrTO = new AttrTO();
testAttrTO.setSchema("testAttribute");
testAttrTO.getValues().add("a value");
@@ -240,7 +240,7 @@ public class AuthenticationITCase extends AbstractITCase {
UserTO userTO = UserITCase.getUniqueSampleTO("checkFailedLogin@syncope.apache.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(7L);
+ membershipTO.setGroupId(7L);
AttrTO testAttrTO = new AttrTO();
testAttrTO.setSchema("testAttribute");
testAttrTO.getValues().add("a value");
@@ -273,7 +273,7 @@ public class AuthenticationITCase extends AbstractITCase {
UserTO userTO = UserITCase.getUniqueSampleTO("checkSuspension@syncope.apache.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(7L);
+ membershipTO.setGroupId(7L);
AttrTO testAttrTO = new AttrTO();
testAttrTO.setSchema("testAttribute");
testAttrTO.getValues().add("a value");
@@ -322,56 +322,56 @@ public class AuthenticationITCase extends AbstractITCase {
@Test
public void issueSYNCOPE48() {
- // Parent role, able to create users with role 1
- RoleTO parentRole = new RoleTO();
- parentRole.setName("parentAdminRole" + getUUIDString());
- parentRole.getEntitlements().add("USER_CREATE");
- parentRole.getEntitlements().add("ROLE_1");
- parentRole.setParent(1L);
- parentRole = createRole(parentRole);
- assertNotNull(parentRole);
-
- // Child role, with no entitlements
- RoleTO childRole = new RoleTO();
- childRole.setName("childAdminRole");
- childRole.setParent(parentRole.getKey());
-
- childRole = createRole(childRole);
- assertNotNull(childRole);
-
- // User with child role, created by admin
- UserTO role1Admin = UserITCase.getUniqueSampleTO("syncope48admin@apache.org");
- role1Admin.setPassword("password");
+ // Parent group, able to create users with group 1
+ GroupTO parentGroup = new GroupTO();
+ parentGroup.setName("parentAdminGroup" + getUUIDString());
+ parentGroup.getEntitlements().add("USER_CREATE");
+ parentGroup.getEntitlements().add("GROUP_1");
+ parentGroup.setParent(1L);
+ parentGroup = createGroup(parentGroup);
+ assertNotNull(parentGroup);
+
+ // Child group, with no entitlements
+ GroupTO childGroup = new GroupTO();
+ childGroup.setName("childAdminGroup");
+ childGroup.setParent(parentGroup.getKey());
+
+ childGroup = createGroup(childGroup);
+ assertNotNull(childGroup);
+
+ // User with child group, created by admin
+ UserTO group1Admin = UserITCase.getUniqueSampleTO("syncope48admin@apache.org");
+ group1Admin.setPassword("password");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(childRole.getKey());
- role1Admin.getMemberships().add(membershipTO);
+ membershipTO.setGroupId(childGroup.getKey());
+ group1Admin.getMemberships().add(membershipTO);
- role1Admin = createUser(role1Admin);
- assertNotNull(role1Admin);
+ group1Admin = createUser(group1Admin);
+ assertNotNull(group1Admin);
- UserService userService2 = clientFactory.create(role1Admin.getUsername(), "password").getService(
+ UserService userService2 = clientFactory.create(group1Admin.getUsername(), "password").getService(
UserService.class);
- // User with role 1, created by user with child role created above
- UserTO role1User = UserITCase.getUniqueSampleTO("syncope48user@apache.org");
+ // User with group 1, created by user with child group created above
+ UserTO group1User = UserITCase.getUniqueSampleTO("syncope48user@apache.org");
membershipTO = new MembershipTO();
- membershipTO.setRoleId(1L);
- role1User.getMemberships().add(membershipTO);
+ membershipTO.setGroupId(1L);
+ group1User.getMemberships().add(membershipTO);
- Response response = userService2.create(role1User, true);
+ Response response = userService2.create(group1User, true);
assertNotNull(response);
- role1User = response.readEntity(UserTO.class);
- assertNotNull(role1User);
+ group1User = response.readEntity(UserTO.class);
+ assertNotNull(group1User);
}
@Test
public void issueSYNCOPE434() {
Assume.assumeTrue(ActivitiDetector.isActivitiEnabledForUsers(syncopeService));
- // 1. create user with role 9 (users with role 9 are defined in workflow as subject to approval)
+ // 1. create user with group 9 (users with group 9 are defined in workflow as subject to approval)
UserTO userTO = UserITCase.getUniqueSampleTO("createWithReject@syncope.apache.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(9L);
+ membershipTO.setGroupId(9L);
userTO.getMemberships().add(membershipTO);
userTO = createUser(userTO);
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
index 47cad19..a061005 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
@@ -26,7 +26,7 @@ public class CamelDetector {
return syncopeService.info().getUserProvisioningManager().indexOf("Camel") != -1;
}
- public static boolean isCamelEnabledForRoles(final SyncopeService syncopeService) {
- return syncopeService.info().getRoleProvisioningManager().indexOf("Camel") != -1;
+ public static boolean isCamelEnabledForGroups(final SyncopeService syncopeService) {
+ return syncopeService.info().getGroupProvisioningManager().indexOf("Camel") != -1;
}
}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
index 1b3e91d..35f270c 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
@@ -50,13 +50,13 @@ public class CamelRouteITCase extends AbstractITCase {
}
@Test
- public void roleRoutes() {
- Assume.assumeTrue(CamelDetector.isCamelEnabledForRoles(syncopeService));
+ public void groupRoutes() {
+ Assume.assumeTrue(CamelDetector.isCamelEnabledForGroups(syncopeService));
- List<CamelRouteTO> roleRoutes = camelRouteService.list(SubjectType.ROLE);
- assertNotNull(roleRoutes);
- assertEquals(7, roleRoutes.size());
- for (CamelRouteTO route : roleRoutes) {
+ List<CamelRouteTO> groupRoutes = camelRouteService.list(SubjectType.GROUP);
+ assertNotNull(groupRoutes);
+ assertEquals(7, groupRoutes.size());
+ for (CamelRouteTO route : groupRoutes) {
assertNotNull(route.getContent());
}
}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
index 27fb19b..3277305 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
@@ -41,7 +41,7 @@ import org.apache.syncope.common.lib.SyncopeConstants;
import org.apache.syncope.common.lib.to.AttrTO;
import org.apache.syncope.common.lib.to.ConfTO;
import org.apache.syncope.common.lib.to.PlainSchemaTO;
-import org.apache.syncope.common.lib.to.RoleTO;
+import org.apache.syncope.common.lib.to.GroupTO;
import org.apache.syncope.common.lib.types.AttrSchemaType;
import org.apache.syncope.common.lib.types.AttributableType;
import org.apache.syncope.common.lib.types.ClientExceptionType;
@@ -194,16 +194,17 @@ public class ConfigurationITCase extends AbstractITCase {
membershipKey.setType(AttrSchemaType.String);
createSchema(AttributableType.MEMBERSHIP, SchemaType.PLAIN, membershipKey);
- PlainSchemaTO roleKey = new PlainSchemaTO();
- roleKey.setKey("roleKey" + getUUIDString());
- roleKey.setType(AttrSchemaType.String);
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, roleKey);
+ PlainSchemaTO groupKey = new PlainSchemaTO();
+ groupKey.setKey("group"
+ + "Key" + getUUIDString());
+ groupKey.setType(AttrSchemaType.String);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, groupKey);
- RoleTO roleTO = new RoleTO();
- roleTO.setName("aRole" + getUUIDString());
- roleTO.getMPlainAttrTemplates().add(membershipKey.getKey());
- roleTO.getRPlainAttrTemplates().add(roleKey.getKey());
- roleTO = createRole(roleTO);
+ GroupTO groupTO = new GroupTO();
+ groupTO.setName("aGroup" + getUUIDString());
+ groupTO.getMPlainAttrTemplates().add(membershipKey.getKey());
+ groupTO.getGPlainAttrTemplates().add(groupKey.getKey());
+ groupTO = createGroup(groupTO);
try {
Response response = configurationService.export();
@@ -219,11 +220,11 @@ public class ConfigurationITCase extends AbstractITCase {
assertFalse(configExport.isEmpty());
assertTrue(configExport.length() > 1000);
- String[] result = substringsBetween(configExport, "<RPLAINATTRTEMPLATE", "/>");
+ String[] result = substringsBetween(configExport, "<GPLAINATTRTEMPLATE", "/>");
assertNotNull(result);
boolean rattrExists = false;
for (String entry : result) {
- if (entry.contains(roleKey.getKey())) {
+ if (entry.contains(groupKey.getKey())) {
rattrExists = true;
}
}
@@ -239,7 +240,7 @@ public class ConfigurationITCase extends AbstractITCase {
}
assertTrue(mattrExists);
} finally {
- deleteRole(roleTO.getKey());
+ deleteGroup(groupTO.getKey());
}
}
}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
index a5c14ad..adbcdf7 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
@@ -71,19 +71,19 @@ public class DerSchemaITCase extends AbstractITCase {
@Test
public void delete() {
- DerSchemaTO schema = schemaService.read(AttributableType.ROLE, SchemaType.DERIVED, "rderiveddata");
+ DerSchemaTO schema = schemaService.read(AttributableType.GROUP, SchemaType.DERIVED, "rderiveddata");
assertNotNull(schema);
- schemaService.delete(AttributableType.ROLE, SchemaType.DERIVED, schema.getKey());
+ schemaService.delete(AttributableType.GROUP, SchemaType.DERIVED, schema.getKey());
try {
- schemaService.read(AttributableType.ROLE, SchemaType.DERIVED, "rderiveddata");
+ schemaService.read(AttributableType.GROUP, SchemaType.DERIVED, "rderiveddata");
fail();
} catch (SyncopeClientException e) {
assertEquals(ClientExceptionType.NotFound, e.getType());
} finally {
// Recreate schema to make test re-runnable
- schema = createSchema(AttributableType.ROLE, SchemaType.DERIVED, schema);
+ schema = createSchema(AttributableType.GROUP, SchemaType.DERIVED, schema);
assertNotNull(schema);
}
}
@@ -113,11 +113,11 @@ public class DerSchemaITCase extends AbstractITCase {
@Test
public void issueSYNCOPE323() {
- DerSchemaTO actual = schemaService.read(AttributableType.ROLE, SchemaType.DERIVED, "rderiveddata");
+ DerSchemaTO actual = schemaService.read(AttributableType.GROUP, SchemaType.DERIVED, "rderiveddata");
assertNotNull(actual);
try {
- createSchema(AttributableType.ROLE, SchemaType.DERIVED, actual);
+ createSchema(AttributableType.GROUP, SchemaType.DERIVED, actual);
fail();
} catch (SyncopeClientException e) {
assertEquals(Response.Status.CONFLICT, e.getType().getResponseStatus());
@@ -126,7 +126,7 @@ public class DerSchemaITCase extends AbstractITCase {
actual.setKey(null);
try {
- createSchema(AttributableType.ROLE, SchemaType.DERIVED, actual);
+ createSchema(AttributableType.GROUP, SchemaType.DERIVED, actual);
fail();
} catch (SyncopeClientException e) {
assertEquals(Response.Status.BAD_REQUEST, e.getType().getResponseStatus());
@@ -141,7 +141,7 @@ public class DerSchemaITCase extends AbstractITCase {
schema.setExpression("derived_sx + '_' + derived_dx");
try {
- createSchema(AttributableType.ROLE, SchemaType.DERIVED, schema);
+ createSchema(AttributableType.GROUP, SchemaType.DERIVED, schema);
fail();
} catch (SyncopeClientException e) {
assertEquals(ClientExceptionType.InvalidDerSchema, e.getType());
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/GroupITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/GroupITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/GroupITCase.java
new file mode 100644
index 0000000..edbb5e1
--- /dev/null
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/GroupITCase.java
@@ -0,0 +1,887 @@
+/*
+ * 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.syncope.fit.core.reference;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.AccessControlException;
+import java.util.List;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.directory.DirContext;
+import javax.naming.directory.SearchControls;
+import javax.naming.directory.SearchResult;
+import javax.ws.rs.core.Response;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.syncope.client.lib.SyncopeClient;
+import org.apache.syncope.common.lib.SyncopeClientException;
+import org.apache.syncope.common.lib.mod.ReferenceMod;
+import org.apache.syncope.common.lib.mod.GroupMod;
+import org.apache.syncope.common.lib.to.BulkActionResult;
+import org.apache.syncope.common.lib.to.ConnObjectTO;
+import org.apache.syncope.common.lib.to.MappingItemTO;
+import org.apache.syncope.common.lib.to.PagedResult;
+import org.apache.syncope.common.lib.to.PlainSchemaTO;
+import org.apache.syncope.common.lib.to.ResourceTO;
+import org.apache.syncope.common.lib.to.GroupTO;
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.ClientExceptionType;
+import org.apache.syncope.common.lib.types.IntMappingType;
+import org.apache.syncope.common.lib.types.MappingPurpose;
+import org.apache.syncope.common.lib.types.ResourceAssociationActionType;
+import org.apache.syncope.common.lib.types.ResourceDeassociationActionType;
+import org.apache.syncope.common.lib.types.SchemaType;
+import org.apache.syncope.common.lib.types.SubjectType;
+import org.apache.syncope.common.lib.wrap.ResourceName;
+import org.apache.syncope.common.rest.api.CollectionWrapper;
+import org.apache.syncope.common.rest.api.Preference;
+import org.apache.syncope.common.rest.api.RESTHeaders;
+import org.apache.syncope.common.rest.api.service.GroupService;
+import org.identityconnectors.framework.common.objects.Name;
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class GroupITCase extends AbstractITCase {
+
+ private GroupTO buildBasicGroupTO(final String name) {
+ GroupTO groupTO = new GroupTO();
+ groupTO.setName(name + getUUIDString());
+ groupTO.setParent(8L);
+ return groupTO;
+ }
+
+ private GroupTO buildGroupTO(final String name) {
+ GroupTO groupTO = buildBasicGroupTO(name);
+
+ // verify inheritance password and account policies
+ groupTO.setInheritAccountPolicy(false);
+ // not inherited so setter execution shouldn't be ignored
+ groupTO.setAccountPolicy(6L);
+
+ groupTO.setInheritPasswordPolicy(true);
+ // inherited so setter execution should be ignored
+ groupTO.setPasswordPolicy(2L);
+
+ groupTO.getGPlainAttrTemplates().add("icon");
+ groupTO.getPlainAttrs().add(attrTO("icon", "anIcon"));
+
+ groupTO.getResources().add(RESOURCE_NAME_LDAP);
+ return groupTO;
+ }
+
+ @Test
+ public void createWithException() {
+ GroupTO newGroupTO = new GroupTO();
+ newGroupTO.getPlainAttrs().add(attrTO("attr1", "value1"));
+
+ try {
+ createGroup(newGroupTO);
+ fail();
+ } catch (SyncopeClientException e) {
+ assertEquals(ClientExceptionType.InvalidGroup, e.getType());
+ }
+ }
+
+ @Test
+ @Ignore
+ public void create() {
+ GroupTO groupTO = buildGroupTO("lastGroup");
+ groupTO.getGVirAttrTemplates().add("rvirtualdata");
+ groupTO.getVirAttrs().add(attrTO("rvirtualdata", "rvirtualvalue"));
+ groupTO.setGroupOwner(8L);
+
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
+
+ assertNotNull(groupTO.getVirAttrMap());
+ assertNotNull(groupTO.getVirAttrMap().get("rvirtualdata").getValues());
+ assertFalse(groupTO.getVirAttrMap().get("rvirtualdata").getValues().isEmpty());
+ assertEquals("rvirtualvalue", groupTO.getVirAttrMap().get("rvirtualdata").getValues().get(0));
+
+ assertNotNull(groupTO.getAccountPolicy());
+ assertEquals(6L, (long) groupTO.getAccountPolicy());
+
+ assertNotNull(groupTO.getPasswordPolicy());
+ assertEquals(4L, (long) groupTO.getPasswordPolicy());
+
+ assertTrue(groupTO.getResources().contains(RESOURCE_NAME_LDAP));
+
+ ConnObjectTO connObjectTO =
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, groupTO.getKey());
+ assertNotNull(connObjectTO);
+ assertNotNull(connObjectTO.getPlainAttrMap().get("owner"));
+
+ // SYNCOPE-515: remove ownership
+ final GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.setGroupOwner(new ReferenceMod());
+
+ assertNull(updateGroup(groupMod).getGroupOwner());
+ }
+
+ @Test
+ public void createWithPasswordPolicy() {
+ GroupTO groupTO = new GroupTO();
+ groupTO.setName("groupWithPassword" + getUUIDString());
+ groupTO.setParent(8L);
+ groupTO.setPasswordPolicy(4L);
+
+ GroupTO actual = createGroup(groupTO);
+ assertNotNull(actual);
+
+ actual = groupService.read(actual.getKey());
+ assertNotNull(actual);
+ assertNotNull(actual.getPasswordPolicy());
+ assertEquals(4L, (long) actual.getPasswordPolicy());
+ }
+
+ @Test
+ public void delete() {
+ try {
+ groupService.delete(0L);
+ } catch (SyncopeClientException e) {
+ assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+ }
+
+ GroupTO groupTO = new GroupTO();
+ groupTO.setName("toBeDeleted" + getUUIDString());
+ groupTO.setParent(8L);
+
+ groupTO.getResources().add(RESOURCE_NAME_LDAP);
+
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
+
+ GroupTO deletedGroup = deleteGroup(groupTO.getKey());
+ assertNotNull(deletedGroup);
+
+ try {
+ groupService.read(deletedGroup.getKey());
+ } catch (SyncopeClientException e) {
+ assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+ }
+ }
+
+ @Test
+ public void list() {
+ PagedResult<GroupTO> groupTOs = groupService.list();
+ assertNotNull(groupTOs);
+ assertTrue(groupTOs.getResult().size() >= 8);
+ for (GroupTO groupTO : groupTOs.getResult()) {
+ assertNotNull(groupTO);
+ }
+ }
+
+ @Test
+ public void parent() {
+ GroupTO groupTO = groupService.parent(7L);
+
+ assertNotNull(groupTO);
+ assertEquals(groupTO.getKey(), 6L);
+ }
+
+ @Test
+ public void read() {
+ GroupTO groupTO = groupService.read(1L);
+
+ assertNotNull(groupTO);
+ assertNotNull(groupTO.getPlainAttrs());
+ assertFalse(groupTO.getPlainAttrs().isEmpty());
+ }
+
+ @Test
+ public void selfRead() {
+ UserTO userTO = userService.read(1L);
+ assertNotNull(userTO);
+
+ assertTrue(userTO.getMembershipMap().containsKey(1L));
+ assertFalse(userTO.getMembershipMap().containsKey(3L));
+
+ GroupService groupService2 = clientFactory.create("rossini", ADMIN_PWD).getService(GroupService.class);
+
+ try {
+ groupService2.readSelf(3L);
+ fail();
+ } catch (SyncopeClientException e) {
+ assertEquals(ClientExceptionType.UnauthorizedGroup, e.getType());
+ }
+
+ GroupTO groupTO = groupService2.readSelf(1L);
+ assertNotNull(groupTO);
+ assertNotNull(groupTO.getPlainAttrs());
+ assertFalse(groupTO.getPlainAttrs().isEmpty());
+ }
+
+ @Test
+ public void update() {
+ GroupTO groupTO = buildGroupTO("latestGroup" + getUUIDString());
+ groupTO.getGPlainAttrTemplates().add("show");
+ groupTO = createGroup(groupTO);
+
+ assertEquals(1, groupTO.getPlainAttrs().size());
+
+ assertNotNull(groupTO.getAccountPolicy());
+ assertEquals(6L, (long) groupTO.getAccountPolicy());
+
+ assertNotNull(groupTO.getPasswordPolicy());
+ assertEquals(4L, (long) groupTO.getPasswordPolicy());
+
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ String modName = "finalGroup" + getUUIDString();
+ groupMod.setName(modName);
+ groupMod.getPlainAttrsToUpdate().add(attrMod("show", "FALSE"));
+
+ // change password policy inheritance
+ groupMod.setInheritPasswordPolicy(Boolean.FALSE);
+
+ groupTO = updateGroup(groupMod);
+
+ assertEquals(modName, groupTO.getName());
+ assertEquals(2, groupTO.getPlainAttrs().size());
+
+ // changes ignored because not requested (null ReferenceMod)
+ assertNotNull(groupTO.getAccountPolicy());
+ assertEquals(6L, (long) groupTO.getAccountPolicy());
+
+ // password policy null because not inherited
+ assertNull(groupTO.getPasswordPolicy());
+ }
+
+ @Test
+ public void updateRemovingVirAttribute() {
+ GroupTO groupTO = buildBasicGroupTO("withvirtual" + getUUIDString());
+ groupTO.getGVirAttrTemplates().add("rvirtualdata");
+ groupTO.getVirAttrs().add(attrTO("rvirtualdata", null));
+
+ groupTO = createGroup(groupTO);
+
+ assertNotNull(groupTO);
+ assertEquals(1, groupTO.getVirAttrs().size());
+
+ final GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.getVirAttrsToRemove().add("rvirtualdata");
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+ assertTrue(groupTO.getVirAttrs().isEmpty());
+ }
+
+ @Test
+ public void updateRemovingDerAttribute() {
+ GroupTO groupTO = buildBasicGroupTO("withderived" + getUUIDString());
+ groupTO.getGDerAttrTemplates().add("rderivedschema");
+ groupTO.getDerAttrs().add(attrTO("rderivedschema", null));
+
+ groupTO = createGroup(groupTO);
+
+ assertNotNull(groupTO);
+ assertEquals(1, groupTO.getDerAttrs().size());
+
+ final GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.getDerAttrsToRemove().add("rderivedschema");
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+ assertTrue(groupTO.getDerAttrs().isEmpty());
+ }
+
+ @Test
+ public void updateAsGroupOwner() {
+ // 1. read group as admin
+ GroupTO groupTO = groupService.read(7L);
+
+ // issue SYNCOPE-15
+ assertNotNull(groupTO.getCreationDate());
+ assertNotNull(groupTO.getLastChangeDate());
+ assertEquals("admin", groupTO.getCreator());
+ assertEquals("admin", groupTO.getLastModifier());
+
+ // 2. prepare update
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.setName("Managing Director");
+
+ // 3. try to update as verdi, not owner of group 7 - fail
+ GroupService groupService2 = clientFactory.create("verdi", ADMIN_PWD).getService(GroupService.class);
+
+ try {
+ groupService2.update(groupMod.getKey(), groupMod);
+ fail();
+ } catch (SyncopeClientException e) {
+ assertEquals(Response.Status.UNAUTHORIZED, e.getType().getResponseStatus());
+ } catch (AccessControlException e) {
+ assertNotNull(e);
+ }
+
+ // 4. update as puccini, owner of group 7 because owner of group 6 with inheritance - success
+ GroupService groupService3 = clientFactory.create("puccini", ADMIN_PWD).getService(GroupService.class);
+
+ groupTO = groupService3.update(groupMod.getKey(), groupMod).readEntity(GroupTO.class);
+ assertEquals("Managing Director", groupTO.getName());
+
+ // issue SYNCOPE-15
+ assertNotNull(groupTO.getCreationDate());
+ assertNotNull(groupTO.getLastChangeDate());
+ assertEquals("admin", groupTO.getCreator());
+ assertEquals("puccini", groupTO.getLastModifier());
+ assertTrue(groupTO.getCreationDate().before(groupTO.getLastChangeDate()));
+ }
+
+ /**
+ * Group rename used to fail in case of parent null.
+ */
+ @Test
+ public void issue178() {
+ GroupTO groupTO = new GroupTO();
+ String groupName = "torename" + getUUIDString();
+ groupTO.setName(groupName);
+
+ GroupTO actual = createGroup(groupTO);
+
+ assertNotNull(actual);
+ assertEquals(groupName, actual.getName());
+ assertEquals(0L, actual.getParent());
+
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(actual.getKey());
+ String renamedGroup = "renamed" + getUUIDString();
+ groupMod.setName(renamedGroup);
+
+ actual = updateGroup(groupMod);
+ assertNotNull(actual);
+ assertEquals(renamedGroup, actual.getName());
+ assertEquals(0L, actual.getParent());
+ }
+
+ @Test
+ public void issueSYNCOPE228() {
+ GroupTO groupTO = buildGroupTO("issueSYNCOPE228");
+ groupTO.getEntitlements().add("USER_READ");
+ groupTO.getEntitlements().add("SCHEMA_READ");
+
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
+ assertNotNull(groupTO.getEntitlements());
+ assertFalse(groupTO.getEntitlements().isEmpty());
+
+ List<String> entitlements = groupTO.getEntitlements();
+
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.setInheritDerAttrs(Boolean.TRUE);
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+ assertEquals(entitlements, groupTO.getEntitlements());
+
+ groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.setModEntitlements(true);
+ groupMod.getEntitlements().clear();
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+ assertTrue(groupTO.getEntitlements().isEmpty());
+ }
+
+ @Test
+ public void unlink() {
+ GroupTO actual = createGroup(buildGroupTO("unlink"));
+ assertNotNull(actual);
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+
+ assertNotNull(groupService.bulkDeassociation(actual.getKey(),
+ ResourceDeassociationActionType.UNLINK,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertNotNull(actual);
+ assertTrue(actual.getResources().isEmpty());
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+ }
+
+ @Test
+ public void link() {
+ GroupTO groupTO = buildGroupTO("link");
+ groupTO.getResources().clear();
+
+ GroupTO actual = createGroup(groupTO);
+ assertNotNull(actual);
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+
+ assertNotNull(groupService.bulkAssociation(actual.getKey(),
+ ResourceAssociationActionType.LINK,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertFalse(actual.getResources().isEmpty());
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+ }
+
+ @Test
+ public void unassign() {
+ GroupTO actual = createGroup(buildGroupTO("unassign"));
+ assertNotNull(actual);
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+
+ assertNotNull(groupService.bulkDeassociation(actual.getKey(),
+ ResourceDeassociationActionType.UNASSIGN,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertNotNull(actual);
+ assertTrue(actual.getResources().isEmpty());
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+ }
+
+ @Test
+ public void assign() {
+ GroupTO groupTO = buildGroupTO("assign");
+ groupTO.getResources().clear();
+
+ GroupTO actual = createGroup(groupTO);
+ assertNotNull(actual);
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+
+ assertNotNull(groupService.bulkAssociation(actual.getKey(),
+ ResourceAssociationActionType.ASSIGN,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertFalse(actual.getResources().isEmpty());
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+ }
+
+ @Test
+ public void deprovision() {
+ GroupTO actual = createGroup(buildGroupTO("deprovision"));
+ assertNotNull(actual);
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+
+ assertNotNull(groupService.bulkDeassociation(actual.getKey(),
+ ResourceDeassociationActionType.DEPROVISION,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertNotNull(actual);
+ assertFalse(actual.getResources().isEmpty());
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+ }
+
+ @Test
+ public void provision() {
+ GroupTO groupTO = buildGroupTO("assign");
+ groupTO.getResources().clear();
+
+ GroupTO actual = createGroup(groupTO);
+ assertNotNull(actual);
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+
+ assertNotNull(groupService.bulkAssociation(actual.getKey(),
+ ResourceAssociationActionType.PROVISION,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertTrue(actual.getResources().isEmpty());
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+ }
+
+ @Test
+ public void deprovisionUnlinked() {
+ GroupTO groupTO = buildGroupTO("assign");
+ groupTO.getResources().clear();
+
+ GroupTO actual = createGroup(groupTO);
+ assertNotNull(actual);
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+
+ assertNotNull(groupService.bulkAssociation(actual.getKey(),
+ ResourceAssociationActionType.PROVISION,
+ CollectionWrapper.wrap("resource-ldap", ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertTrue(actual.getResources().isEmpty());
+
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey()));
+
+ assertNotNull(groupService.bulkDeassociation(actual.getKey(),
+ ResourceDeassociationActionType.DEPROVISION,
+ CollectionWrapper.wrap(RESOURCE_NAME_LDAP, ResourceName.class)).
+ readEntity(BulkActionResult.class));
+
+ actual = groupService.read(actual.getKey());
+ assertNotNull(actual);
+ assertTrue(actual.getResources().isEmpty());
+
+ try {
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, actual.getKey());
+ fail();
+ } catch (Exception e) {
+ assertNotNull(e);
+ }
+ }
+
+ @Test
+ public void createWithMandatorySchemaNotTemplate() {
+ // 1. create a group mandatory schema
+ PlainSchemaTO badge = new PlainSchemaTO();
+ badge.setKey("badge");
+ badge.setMandatoryCondition("true");
+ schemaService.create(AttributableType.GROUP, SchemaType.PLAIN, badge);
+
+ // 2. create a group *without* an attribute for that schema: it works
+ GroupTO groupTO = buildGroupTO("lastGroup");
+ assertFalse(groupTO.getPlainAttrMap().containsKey(badge.getKey()));
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
+ assertFalse(groupTO.getPlainAttrMap().containsKey(badge.getKey()));
+
+ // 3. add a template for badge to the group just created -
+ // failure since no values are provided and it is mandatory
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.setModRAttrTemplates(true);
+ groupMod.getRPlainAttrTemplates().add("badge");
+
+ try {
+ updateGroup(groupMod);
+ fail();
+ } catch (SyncopeClientException e) {
+ assertEquals(ClientExceptionType.RequiredValuesMissing, e.getType());
+ }
+
+ // 4. also add an actual attribute for badge - it will work
+ groupMod.getPlainAttrsToUpdate().add(attrMod(badge.getKey(), "xxxxxxxxxx"));
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+ assertTrue(groupTO.getPlainAttrMap().containsKey(badge.getKey()));
+ }
+
+ @Test
+ public void anonymous() {
+ GroupService unauthenticated = clientFactory.createAnonymous().getService(GroupService.class);
+ try {
+ unauthenticated.list();
+ fail();
+ } catch (AccessControlException e) {
+ assertNotNull(e);
+ }
+
+ GroupService anonymous = clientFactory.create(ANONYMOUS_UNAME, ANONYMOUS_KEY).getService(GroupService.class);
+ assertFalse(anonymous.list().getResult().isEmpty());
+ }
+
+ @Test
+ public void noContent() throws IOException {
+ SyncopeClient noContentclient = clientFactory.create(ADMIN_UNAME, ADMIN_PWD);
+ GroupService noContentService = noContentclient.prefer(GroupService.class, Preference.RETURN_NO_CONTENT);
+
+ GroupTO group = buildGroupTO("noContent");
+
+ Response response = noContentService.create(group);
+ assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());
+ assertEquals(Preference.RETURN_NO_CONTENT.toString(), response.getHeaderString(RESTHeaders.PREFERENCE_APPLIED));
+ assertEquals(StringUtils.EMPTY, IOUtils.toString((InputStream) response.getEntity()));
+
+ group = getObject(response.getLocation(), GroupService.class, GroupTO.class);
+ assertNotNull(group);
+
+ GroupMod groupMod = new GroupMod();
+ groupMod.getPlainAttrsToUpdate().add(attrMod("badge", "xxxxxxxxxx"));
+
+ response = noContentService.update(group.getKey(), groupMod);
+ assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
+ assertEquals(Preference.RETURN_NO_CONTENT.toString(), response.getHeaderString(RESTHeaders.PREFERENCE_APPLIED));
+ assertEquals(StringUtils.EMPTY, IOUtils.toString((InputStream) response.getEntity()));
+
+ response = noContentService.delete(group.getKey());
+ assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
+ assertEquals(Preference.RETURN_NO_CONTENT.toString(), response.getHeaderString(RESTHeaders.PREFERENCE_APPLIED));
+ assertEquals(StringUtils.EMPTY, IOUtils.toString((InputStream) response.getEntity()));
+ }
+
+ @Test
+ public void issueSYNCOPE455() {
+ final String parentName = "issueSYNCOPE455-PGroup";
+ final String childName = "issueSYNCOPE455-CGroup";
+
+ // 1. create parent group
+ GroupTO parent = buildBasicGroupTO(parentName);
+ parent.getResources().add(RESOURCE_NAME_LDAP);
+
+ parent = createGroup(parent);
+ assertTrue(parent.getResources().contains(RESOURCE_NAME_LDAP));
+
+ final ConnObjectTO parentRemoteObject =
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, parent.getKey());
+ assertNotNull(parentRemoteObject);
+ assertNotNull(getLdapRemoteObject(parentRemoteObject.getPlainAttrMap().get(Name.NAME).getValues().get(0)));
+
+ // 2. create child group
+ GroupTO child = buildBasicGroupTO(childName);
+ child.getResources().add(RESOURCE_NAME_LDAP);
+ child.setParent(parent.getKey());
+
+ child = createGroup(child);
+ assertTrue(child.getResources().contains(RESOURCE_NAME_LDAP));
+
+ final ConnObjectTO childRemoteObject =
+ resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, child.getKey());
+ assertNotNull(childRemoteObject);
+ assertNotNull(getLdapRemoteObject(childRemoteObject.getPlainAttrMap().get(Name.NAME).getValues().get(0)));
+
+ // 3. remove parent group
+ groupService.delete(parent.getKey());
+
+ // 4. asserts for issue 455
+ try {
+ groupService.read(parent.getKey());
+ fail();
+ } catch (SyncopeClientException scce) {
+ assertNotNull(scce);
+ }
+
+ try {
+ groupService.read(child.getKey());
+ fail();
+ } catch (SyncopeClientException scce) {
+ assertNotNull(scce);
+ }
+
+ assertNull(getLdapRemoteObject(parentRemoteObject.getPlainAttrMap().get(Name.NAME).getValues().get(0)));
+ assertNull(getLdapRemoteObject(childRemoteObject.getPlainAttrMap().get(Name.NAME).getValues().get(0)));
+ }
+
+ @Test
+ public void issueSYNCOPE543() {
+ final String ancestorName = "issueSYNCOPE543-AGroup";
+ final String parentName = "issueSYNCOPE543-PGroup";
+ final String childName = "issueSYNCOPE543-CGroup";
+
+ // 1. create ancestor group
+ GroupTO ancestor = buildBasicGroupTO(ancestorName);
+ ancestor.setParent(0L);
+ ancestor.getGPlainAttrTemplates().add("icon");
+ ancestor.getPlainAttrs().add(attrTO("icon", "ancestorIcon"));
+ ancestor = createGroup(ancestor);
+ assertEquals("ancestorIcon", ancestor.getPlainAttrMap().get("icon").getValues().get(0));
+
+ // 2. create parent group
+ GroupTO parent = buildBasicGroupTO(parentName);
+ parent.setParent(ancestor.getKey());
+ parent.getGPlainAttrTemplates().add("icon");
+ parent.getPlainAttrs().add(attrTO("icon", "parentIcon"));
+ parent = createGroup(parent);
+ assertEquals("parentIcon", parent.getPlainAttrMap().get("icon").getValues().get(0));
+
+ // 3. create child group
+ GroupTO child = buildBasicGroupTO(childName);
+ child.setParent(parent.getKey());
+ child.getGPlainAttrTemplates().add("icon");
+ child.getPlainAttrs().add(attrTO("icon", "childIcon"));
+ child = createGroup(child);
+ assertEquals("childIcon", child.getPlainAttrMap().get("icon").getValues().get(0));
+
+ final GroupMod groupChildMod = new GroupMod();
+ groupChildMod.setKey(child.getKey());
+ groupChildMod.setInheritPlainAttrs(Boolean.TRUE);
+ updateGroup(groupChildMod);
+
+ child = groupService.read(child.getKey());
+ assertNotNull(child);
+ assertNotNull(child.getPlainAttrMap().get("icon").getValues());
+ assertEquals("parentIcon", child.getPlainAttrMap().get("icon").getValues().get(0));
+
+ final GroupMod groupParentMod = new GroupMod();
+ groupParentMod.setKey(parent.getKey());
+ groupParentMod.setInheritPlainAttrs(Boolean.TRUE);
+ updateGroup(groupParentMod);
+
+ child = groupService.read(child.getKey());
+ assertNotNull(child);
+ assertNotNull(child.getPlainAttrMap().get("icon").getValues());
+ assertEquals("ancestorIcon", child.getPlainAttrMap().get("icon").getValues().get(0));
+
+ parent = groupService.read(parent.getKey());
+ assertNotNull(parent);
+ assertNotNull(parent.getPlainAttrMap().get("icon").getValues());
+ assertEquals("ancestorIcon", parent.getPlainAttrMap().get("icon").getValues().get(0));
+
+ groupParentMod.setInheritPlainAttrs(Boolean.FALSE);
+ updateGroup(groupParentMod);
+
+ child = groupService.read(child.getKey());
+ assertNotNull(child);
+ assertNotNull(child.getPlainAttrMap().get("icon").getValues());
+ assertEquals("parentIcon", child.getPlainAttrMap().get("icon").getValues().get(0));
+ }
+
+ @Test
+ public void issueSYNCOPE632() {
+ GroupTO groupTO = null;
+ try {
+ // 1. create new LDAP resource having account id mapped to a derived attribute
+ ResourceTO newLDAP = resourceService.read(RESOURCE_NAME_LDAP);
+ newLDAP.setKey("new-ldap");
+ newLDAP.setPropagationPrimary(true);
+ MappingItemTO accountId = newLDAP.getGmapping().getAccountIdItem();
+ accountId.setIntMappingType(IntMappingType.GroupDerivedSchema);
+ accountId.setIntAttrName("displayProperty");
+ newLDAP.getGmapping().setAccountIdItem(accountId);
+ newLDAP.getGmapping().setAccountLink("'cn=' + displayProperty + ',ou=groups,o=isp'");
+
+ MappingItemTO description = new MappingItemTO();
+ description.setIntMappingType(IntMappingType.GroupId);
+ description.setExtAttrName("description");
+ description.setPurpose(MappingPurpose.BOTH);
+ newLDAP.getGmapping().addItem(description);
+
+ newLDAP = createResource(newLDAP);
+ assertNotNull(newLDAP);
+
+ // 2. create a group and give the resource created above
+ groupTO = buildGroupTO("lastGroup");
+ groupTO.getGPlainAttrTemplates().add("icon");
+ groupTO.getPlainAttrs().add(attrTO("icon", "anIcon"));
+ groupTO.getGPlainAttrTemplates().add("show");
+ groupTO.getPlainAttrs().add(attrTO("show", "true"));
+ groupTO.getGDerAttrTemplates().add("displayProperty");
+ groupTO.getDerAttrs().add(attrTO("displayProperty", null));
+ groupTO.getResources().clear();
+ groupTO.getResources().add("new-ldap");
+
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
+
+ // 3. update the group
+ GroupMod groupMod = new GroupMod();
+ groupMod.setKey(groupTO.getKey());
+ groupMod.getPlainAttrsToRemove().add("icon");
+ groupMod.getPlainAttrsToUpdate().add(attrMod("icon", "anotherIcon"));
+
+ groupTO = updateGroup(groupMod);
+ assertNotNull(groupTO);
+
+ // 4. check that a single group exists in LDAP for the group created and updated above
+ int entries = 0;
+ DirContext ctx = null;
+ try {
+ ctx = getLdapResourceDirContext(null, null);
+
+ SearchControls ctls = new SearchControls();
+ ctls.setReturningAttributes(new String[] { "*", "+" });
+ ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
+
+ NamingEnumeration<SearchResult> result =
+ ctx.search("ou=groups,o=isp", "(description=" + groupTO.getKey() + ")", ctls);
+ while (result.hasMore()) {
+ result.next();
+ entries++;
+ }
+ } catch (Exception e) {
+ // ignore
+ } finally {
+ if (ctx != null) {
+ try {
+ ctx.close();
+ } catch (NamingException e) {
+ // ignore
+ }
+ }
+ }
+
+ assertEquals(1, entries);
+ } finally {
+ if (groupTO != null) {
+ groupService.delete(groupTO.getKey());
+ }
+ resourceService.delete("new-ldap");
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
index 7b5e845..012c6ab 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
@@ -37,7 +37,7 @@ import org.apache.syncope.common.lib.types.ResourceOperation;
import org.apache.syncope.common.rest.api.CollectionWrapper;
import org.apache.syncope.core.logic.ReportLogic;
import org.apache.syncope.core.logic.ResourceLogic;
-import org.apache.syncope.core.logic.RoleLogic;
+import org.apache.syncope.core.logic.GroupLogic;
import org.apache.syncope.core.logic.UserLogic;
import org.junit.FixMethodOrder;
import org.junit.Test;
@@ -143,7 +143,7 @@ public class LoggerITCase extends AbstractITCase {
found = false;
for (EventCategoryTO eventCategoryTO : events) {
- if (RoleLogic.class.getSimpleName().equals(eventCategoryTO.getCategory())) {
+ if (GroupLogic.class.getSimpleName().equals(eventCategoryTO.getCategory())) {
assertEquals(EventCategoryType.REST, eventCategoryTO.getType());
assertTrue(eventCategoryTO.getEvents().contains("create"));
assertTrue(eventCategoryTO.getEvents().contains("list"));
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationITCase.java
index 03a557f..d5c9570 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationITCase.java
@@ -75,7 +75,7 @@ public class NotificationITCase extends AbstractITCase {
@Test
public void create() {
NotificationTO notificationTO = buildNotificationTO();
- notificationTO.setRecipients(SyncopeClient.getUserSearchConditionBuilder().hasRoles(7L).query());
+ notificationTO.setRecipients(SyncopeClient.getUserSearchConditionBuilder().inGroups(7L).query());
Response response = notificationService.create(notificationTO);
NotificationTO actual = getObject(response.getLocation(), NotificationService.class,
@@ -90,7 +90,7 @@ public class NotificationITCase extends AbstractITCase {
@Test
public void update() {
NotificationTO notificationTO = notificationService.read(10L);
- notificationTO.setRecipients(SyncopeClient.getUserSearchConditionBuilder().hasRoles(7L).query());
+ notificationTO.setRecipients(SyncopeClient.getUserSearchConditionBuilder().inGroups(7L).query());
notificationService.update(notificationTO.getKey(), notificationTO);
NotificationTO actual = notificationService.read(notificationTO.getKey());
@@ -155,7 +155,8 @@ public class NotificationITCase extends AbstractITCase {
public void issueSYNCOPE446() {
NotificationTO notificationTO = buildNotificationTO();
notificationTO.getStaticRecipients().add("syncope446@syncope.apache.org");
- notificationTO.setRoleAbout(SyncopeClient.getRoleSearchConditionBuilder().hasEntitlements("ROLE_READ").query());
+ notificationTO.setGroupAbout(
+ SyncopeClient.getGroupSearchConditionBuilder().hasEntitlements("GROUP_READ").query());
NotificationTO actual = null;
try {
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationTaskITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationTaskITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationTaskITCase.java
index ee75de9..1fb1a93 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationTaskITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/NotificationTaskITCase.java
@@ -109,9 +109,9 @@ public class NotificationTaskITCase extends AbstractTaskITCase {
notification.setTraceLevel(TraceLevel.FAILURES);
notification.getEvents().add("[REST]:[UserLogic]:[]:[create]:[SUCCESS]");
- notification.setUserAbout(SyncopeClient.getUserSearchConditionBuilder().hasRoles(7L).query());
+ notification.setUserAbout(SyncopeClient.getUserSearchConditionBuilder().inGroups(7L).query());
- notification.setRecipients(SyncopeClient.getUserSearchConditionBuilder().hasRoles(8L).query());
+ notification.setRecipients(SyncopeClient.getUserSearchConditionBuilder().inGroups(8L).query());
notification.setSelfAsRecipient(true);
notification.setRecipientAttrName("email");
@@ -130,7 +130,7 @@ public class NotificationTaskITCase extends AbstractTaskITCase {
// 2. create user
UserTO userTO = UserITCase.getUniqueSampleTO("syncope@syncope.apache.org");
MembershipTO membershipTO = new MembershipTO();
- membershipTO.setRoleId(7);
+ membershipTO.setGroupId(7);
userTO.getMemberships().add(membershipTO);
userTO = createUser(userTO);
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PlainSchemaITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PlainSchemaITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PlainSchemaITCase.java
index b9d8239..1968206 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PlainSchemaITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PlainSchemaITCase.java
@@ -92,7 +92,7 @@ public class PlainSchemaITCase extends AbstractITCase {
schemaTO.setType(AttrSchemaType.Enum);
try {
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, schemaTO);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, schemaTO);
fail("This should not be reacheable");
} catch (SyncopeClientException e) {
assertEquals(ClientExceptionType.InvalidPlainSchema, e.getType());
@@ -136,7 +136,7 @@ public class PlainSchemaITCase extends AbstractITCase {
schemaTO.setType(AttrSchemaType.Binary);
schemaTO.setMimeType("application/x-x509-ca-cert");
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, schemaTO);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, schemaTO);
}
@Test
@@ -163,9 +163,9 @@ public class PlainSchemaITCase extends AbstractITCase {
assertNotNull(schemaTO);
}
- List<PlainSchemaTO> roleSchemas = schemaService.list(AttributableType.ROLE, SchemaType.PLAIN);
- assertFalse(roleSchemas.isEmpty());
- for (PlainSchemaTO schemaTO : roleSchemas) {
+ List<PlainSchemaTO> groupSchemas = schemaService.list(AttributableType.GROUP, SchemaType.PLAIN);
+ assertFalse(groupSchemas.isEmpty());
+ for (PlainSchemaTO schemaTO : groupSchemas) {
assertNotNull(schemaTO);
}
@@ -178,16 +178,16 @@ public class PlainSchemaITCase extends AbstractITCase {
@Test
public void update() {
- PlainSchemaTO schemaTO = schemaService.read(AttributableType.ROLE, SchemaType.PLAIN, "icon");
+ PlainSchemaTO schemaTO = schemaService.read(AttributableType.GROUP, SchemaType.PLAIN, "icon");
assertNotNull(schemaTO);
- schemaService.update(AttributableType.ROLE, SchemaType.PLAIN, schemaTO.getKey(), schemaTO);
- PlainSchemaTO updatedTO = schemaService.read(AttributableType.ROLE, SchemaType.PLAIN, "icon");
+ schemaService.update(AttributableType.GROUP, SchemaType.PLAIN, schemaTO.getKey(), schemaTO);
+ PlainSchemaTO updatedTO = schemaService.read(AttributableType.GROUP, SchemaType.PLAIN, "icon");
assertEquals(schemaTO, updatedTO);
updatedTO.setType(AttrSchemaType.Date);
try {
- schemaService.update(AttributableType.ROLE, SchemaType.PLAIN, schemaTO.getKey(), updatedTO);
+ schemaService.update(AttributableType.GROUP, SchemaType.PLAIN, schemaTO.getKey(), updatedTO);
fail("This should not be reacheable");
} catch (SyncopeClientException e) {
assertEquals(ClientExceptionType.InvalidPlainSchema, e.getType());
@@ -233,7 +233,7 @@ public class PlainSchemaITCase extends AbstractITCase {
UserTO newUserTO = SerializationUtils.clone(userTO);
MembershipTO membership = new MembershipTO();
- membership.setRoleId(2L);
+ membership.setGroupId(2L);
newUserTO.getMemberships().add(membership);
UserMod userMod = AttributableOperations.diff(newUserTO, userTO);
@@ -266,11 +266,11 @@ public class PlainSchemaITCase extends AbstractITCase {
@Test
public void issueSYNCOPE323() {
- PlainSchemaTO actual = schemaService.read(AttributableType.ROLE, SchemaType.PLAIN, "icon");
+ PlainSchemaTO actual = schemaService.read(AttributableType.GROUP, SchemaType.PLAIN, "icon");
assertNotNull(actual);
try {
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, actual);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, actual);
fail();
} catch (SyncopeClientException e) {
assertEquals(Response.Status.CONFLICT, e.getType().getResponseStatus());
@@ -279,7 +279,7 @@ public class PlainSchemaITCase extends AbstractITCase {
actual.setKey(null);
try {
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, actual);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, actual);
fail();
} catch (SyncopeClientException e) {
assertEquals(Response.Status.BAD_REQUEST, e.getType().getResponseStatus());
@@ -293,7 +293,7 @@ public class PlainSchemaITCase extends AbstractITCase {
AttrSchemaType.Double);
try {
- createSchema(AttributableType.ROLE, SchemaType.PLAIN, schema);
+ createSchema(AttributableType.GROUP, SchemaType.PLAIN, schema);
fail();
} catch (SyncopeClientException e) {
assertEquals(ClientExceptionType.InvalidPlainSchema, e.getType());
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PolicyITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PolicyITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PolicyITCase.java
index 409f29d..bdf3f90 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PolicyITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PolicyITCase.java
@@ -68,7 +68,7 @@ public class PolicyITCase extends AbstractITCase {
assertNotNull(policyTO);
assertTrue(policyTO.getUsedByResources().isEmpty());
- assertEquals(Arrays.asList(6L, 7L, 10L, 14L), policyTO.getUsedByRoles());
+ assertTrue(policyTO.getUsedByGroups().containsAll(Arrays.asList(6L, 7L, 10L, 14L)));
}
@Test
@@ -77,7 +77,7 @@ public class PolicyITCase extends AbstractITCase {
assertNotNull(policyTO);
assertTrue(policyTO.getUsedByResources().contains(RESOURCE_NAME_NOPROPAGATION));
- assertEquals(Arrays.asList(6L, 7L, 10L, 8L), policyTO.getUsedByRoles());
+ assertTrue(policyTO.getUsedByGroups().containsAll(Arrays.asList(6L, 7L, 10L, 8L)));
}
@Test
@@ -85,7 +85,7 @@ public class PolicyITCase extends AbstractITCase {
SyncPolicyTO policyTO = policyService.read(1L);
assertNotNull(policyTO);
- assertTrue(policyTO.getUsedByRoles().isEmpty());
+ assertTrue(policyTO.getUsedByGroups().isEmpty());
}
@Test
@@ -114,7 +114,7 @@ public class PolicyITCase extends AbstractITCase {
assertEquals(PolicyType.GLOBAL_SYNC, policyTO.getType());
assertFalse(policyTO.getUsedByResources().contains(RESOURCE_NAME_CSV));
assertFalse(policyTO.getUsedByResources().contains(RESOURCE_NAME_WS2));
- assertTrue(policyTO.getUsedByRoles().isEmpty());
+ assertTrue(policyTO.getUsedByGroups().isEmpty());
}
@Test
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PushTaskITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PushTaskITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PushTaskITCase.java
index 3427a1d..76da48c 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PushTaskITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/PushTaskITCase.java
@@ -39,7 +39,7 @@ import org.apache.syncope.common.lib.to.PagedResult;
import org.apache.syncope.common.lib.to.PlainSchemaTO;
import org.apache.syncope.common.lib.to.PushTaskTO;
import org.apache.syncope.common.lib.to.ResourceTO;
-import org.apache.syncope.common.lib.to.RoleTO;
+import org.apache.syncope.common.lib.to.GroupTO;
import org.apache.syncope.common.lib.to.TaskExecTO;
import org.apache.syncope.common.lib.types.AttrSchemaType;
import org.apache.syncope.common.lib.types.AttributableType;
@@ -94,8 +94,8 @@ public class PushTaskITCase extends AbstractTaskITCase {
task.setResource(RESOURCE_NAME_WS2);
task.setUserFilter(
SyncopeClient.getUserSearchConditionBuilder().hasNotResources(RESOURCE_NAME_TESTDB2).query());
- task.setRoleFilter(
- SyncopeClient.getRoleSearchConditionBuilder().isNotNull("cool").query());
+ task.setGroupFilter(
+ SyncopeClient.getGroupSearchConditionBuilder().isNotNull("cool").query());
task.setMatchingRule(MatchingRule.LINK);
final Response response = taskService.create(task);
@@ -107,24 +107,24 @@ public class PushTaskITCase extends AbstractTaskITCase {
assertEquals(task.getKey(), actual.getKey());
assertEquals(task.getJobClassName(), actual.getJobClassName());
assertEquals(task.getUserFilter(), actual.getUserFilter());
- assertEquals(task.getRoleFilter(), actual.getRoleFilter());
+ assertEquals(task.getGroupFilter(), actual.getGroupFilter());
assertEquals(UnmatchingRule.ASSIGN, actual.getUnmatchingRule());
assertEquals(MatchingRule.LINK, actual.getMatchingRule());
}
@Test
- public void pushMatchingUnmatchingRoles() {
- assertFalse(roleService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
+ public void pushMatchingUnmatchingGroups() {
+ assertFalse(groupService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
execSyncTask(23L, 50, false);
- assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.ROLE, 3L));
- assertTrue(roleService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, 3L));
+ assertTrue(groupService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
execSyncTask(23L, 50, false);
- assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.ROLE, 3L));
- assertFalse(roleService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
+ assertNotNull(resourceService.getConnectorObject(RESOURCE_NAME_LDAP, SubjectType.GROUP, 3L));
+ assertFalse(groupService.read(3L).getResources().contains(RESOURCE_NAME_LDAP));
}
@Test
@@ -247,27 +247,27 @@ public class PushTaskITCase extends AbstractTaskITCase {
@Test
public void issueSYNCOPE598() {
- // create a new role schema
+ // create a new group schema
final PlainSchemaTO schemaTO = new PlainSchemaTO();
schemaTO.setKey("LDAPGroupName" + getUUIDString());
schemaTO.setType(AttrSchemaType.String);
schemaTO.setMandatoryCondition("true");
- final PlainSchemaTO newPlainSchemaTO = createSchema(AttributableType.ROLE, SchemaType.PLAIN, schemaTO);
+ final PlainSchemaTO newPlainSchemaTO = createSchema(AttributableType.GROUP, SchemaType.PLAIN, schemaTO);
assertEquals(schemaTO, newPlainSchemaTO);
- // create a new sample role
- RoleTO roleTO = new RoleTO();
- roleTO.setName("all" + getUUIDString());
- roleTO.setParent(8L);
+ // create a new sample group
+ GroupTO groupTO = new GroupTO();
+ groupTO.setName("all" + getUUIDString());
+ groupTO.setParent(8L);
- roleTO.getRPlainAttrTemplates().add(newPlainSchemaTO.getKey());
- roleTO.getPlainAttrs().add(attrTO(newPlainSchemaTO.getKey(), "all"));
+ groupTO.getGPlainAttrTemplates().add(newPlainSchemaTO.getKey());
+ groupTO.getPlainAttrs().add(attrTO(newPlainSchemaTO.getKey(), "all"));
- roleTO = createRole(roleTO);
- assertNotNull(roleTO);
+ groupTO = createGroup(groupTO);
+ assertNotNull(groupTO);
- String resourceName = "resource-ldap-roleonly";
+ String resourceName = "resource-ldap-grouponly";
ResourceTO newResourceTO = null;
try {
@@ -311,7 +311,7 @@ public class PushTaskITCase extends AbstractTaskITCase {
final MappingTO rmapping = new MappingTO();
item = new MappingItemTO();
- item.setIntMappingType(IntMappingType.RolePlainSchema);
+ item.setIntMappingType(IntMappingType.GroupPlainSchema);
item.setExtAttrName("cn");
item.setIntAttrName(newPlainSchemaTO.getKey());
item.setAccountid(true);
@@ -320,14 +320,14 @@ public class PushTaskITCase extends AbstractTaskITCase {
rmapping.setAccountLink("'cn=' + " + newPlainSchemaTO.getKey() + " + ',ou=groups,o=isp'");
- resourceTO.setRmapping(rmapping);
+ resourceTO.setGmapping(rmapping);
Response response = resourceService.create(resourceTO);
newResourceTO = getObject(response.getLocation(), ResourceService.class, ResourceTO.class);
assertNotNull(newResourceTO);
assertNull(newResourceTO.getUmapping());
- assertNotNull(newResourceTO.getRmapping());
+ assertNotNull(newResourceTO.getGmapping());
// create push task ad-hoc
final PushTaskTO task = new PushTaskTO();
@@ -348,7 +348,7 @@ public class PushTaskITCase extends AbstractTaskITCase {
final TaskExecTO pushExec = execSyncTask(push.getKey(), 50, false);
assertTrue(PropagationTaskExecStatus.valueOf(pushExec.getStatus()).isSuccessful());
} finally {
- roleService.delete(roleTO.getKey());
+ groupService.delete(groupTO.getKey());
if (newResourceTO != null) {
resourceService.delete(resourceName);
}
@@ -363,8 +363,8 @@ public class PushTaskITCase extends AbstractTaskITCase {
task.setResource(RESOURCE_NAME_LDAP);
task.setUserFilter(
SyncopeClient.getUserSearchConditionBuilder().is("username").equalTo("_NO_ONE_").query());
- task.setRoleFilter(
- SyncopeClient.getRoleSearchConditionBuilder().is("name").equalTo("citizen").query());
+ task.setGroupFilter(
+ SyncopeClient.getGroupSearchConditionBuilder().is("name").equalTo("citizen").query());
task.setMatchingRule(MatchingRule.IGNORE);
task.setUnmatchingRule(UnmatchingRule.IGNORE);
@@ -375,8 +375,8 @@ public class PushTaskITCase extends AbstractTaskITCase {
// 2. Create notification
NotificationTO notification = new NotificationTO();
notification.setTraceLevel(TraceLevel.FAILURES);
- notification.getEvents().add("[PushTask]:[role]:[resource-ldap]:[matchingrule_ignore]:[SUCCESS]");
- notification.getEvents().add("[PushTask]:[role]:[resource-ldap]:[unmatchingrule_ignore]:[SUCCESS]");
+ notification.getEvents().add("[PushTask]:[group]:[resource-ldap]:[matchingrule_ignore]:[SUCCESS]");
+ notification.getEvents().add("[PushTask]:[group]:[resource-ldap]:[unmatchingrule_ignore]:[SUCCESS]");
notification.getStaticRecipients().add("issueyncope648@syncope.apache.org");
notification.setSelfAsRecipient(false);
http://git-wip-us.apache.org/repos/asf/syncope/blob/4095f1e8/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ResourceITCase.java
----------------------------------------------------------------------
diff --git a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ResourceITCase.java b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ResourceITCase.java
index f3618d3..90664b0 100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ResourceITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ResourceITCase.java
@@ -182,13 +182,13 @@ public class ResourceITCase extends AbstractITCase {
MappingTO rmapping = new MappingTO();
item = new MappingItemTO();
- item.setIntMappingType(IntMappingType.RoleId);
- item.setExtAttrName("roleId");
+ item.setIntMappingType(IntMappingType.GroupId);
+ item.setExtAttrName("groupId");
item.setAccountid(true);
item.setPurpose(MappingPurpose.SYNCHRONIZATION);
rmapping.setAccountIdItem(item);
- resourceTO.setRmapping(rmapping);
+ resourceTO.setGmapping(rmapping);
Response response = resourceService.create(resourceTO);
ResourceTO actual = getObject(response.getLocation(), ResourceService.class, ResourceTO.class);
@@ -196,9 +196,9 @@ public class ResourceITCase extends AbstractITCase {
assertNotNull(actual);
assertNotNull(actual.getUmapping());
assertNotNull(actual.getUmapping().getItems());
- assertNotNull(actual.getRmapping());
- assertNotNull(actual.getRmapping().getItems());
- assertEquals(MappingPurpose.SYNCHRONIZATION, actual.getRmapping().getAccountIdItem().getPurpose());
+ assertNotNull(actual.getGmapping());
+ assertNotNull(actual.getGmapping().getItems());
+ assertEquals(MappingPurpose.SYNCHRONIZATION, actual.getGmapping().getAccountIdItem().getPurpose());
assertEquals(MappingPurpose.PROPAGATION, actual.getUmapping().getAccountIdItem().getPurpose());
}
@@ -489,22 +489,22 @@ public class ResourceITCase extends AbstractITCase {
MappingTO mapping = new MappingTO();
MappingItemTO item = new MappingItemTO();
- item.setIntMappingType(IntMappingType.RoleName);
+ item.setIntMappingType(IntMappingType.GroupName);
item.setExtAttrName("cn");
item.setPurpose(MappingPurpose.BOTH);
mapping.setAccountIdItem(item);
item = new MappingItemTO();
- item.setIntMappingType(IntMappingType.RoleOwnerSchema);
+ item.setIntMappingType(IntMappingType.GroupOwnerSchema);
item.setExtAttrName("owner");
item.setPurpose(MappingPurpose.BOTH);
mapping.addItem(item);
- resourceTO.setRmapping(mapping);
+ resourceTO.setGmapping(mapping);
resourceTO = createResource(resourceTO);
assertNotNull(resourceTO);
- assertEquals(2, resourceTO.getRmapping().getItems().size());
+ assertEquals(2, resourceTO.getGmapping().getItems().size());
}
@Test