syncope-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ilgro...@apache.org
Subject [06/54] [abbrv] [partial] syncope git commit: [SYNCOPE-620] Renaming 'server' after 'core', to provide continuity with older releases (especially for archetype)
Date Thu, 12 Feb 2015 09:14:11 GMT
http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
new file mode 100644
index 0000000..4623f25
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/AuthenticationITCase.java
@@ -0,0 +1,440 @@
+/*
+ * 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.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.security.AccessControlException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ws.rs.core.Response;
+import org.apache.syncope.client.lib.SyncopeClient;
+import org.apache.syncope.common.lib.SyncopeClientException;
+import org.apache.syncope.common.lib.mod.StatusMod;
+import org.apache.syncope.common.lib.mod.UserMod;
+import org.apache.syncope.common.lib.to.AttrTO;
+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.UserTO;
+import org.apache.syncope.common.lib.to.WorkflowFormPropertyTO;
+import org.apache.syncope.common.lib.to.WorkflowFormTO;
+import org.apache.syncope.common.lib.types.AttrSchemaType;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.CipherAlgorithm;
+import org.apache.syncope.common.lib.types.ClientExceptionType;
+import org.apache.syncope.common.lib.types.ResourceDeassociationActionType;
+import org.apache.syncope.common.lib.types.SchemaType;
+import org.apache.syncope.common.lib.wrap.EntitlementTO;
+import org.apache.syncope.common.lib.wrap.ResourceName;
+import org.apache.syncope.common.rest.api.CollectionWrapper;
+import org.apache.syncope.common.rest.api.service.EntitlementService;
+import org.apache.syncope.common.rest.api.service.SchemaService;
+import org.apache.syncope.common.rest.api.service.UserSelfService;
+import org.apache.syncope.common.rest.api.service.UserService;
+import org.apache.syncope.core.misc.security.Encryptor;
+import org.junit.Assume;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class AuthenticationITCase extends AbstractITCase {
+
+    private int getFailedLogins(UserService testUserService, long userId) {
+        UserTO readUserTO = testUserService.read(userId);
+        assertNotNull(readUserTO);
+        assertNotNull(readUserTO.getFailedLogins());
+        return readUserTO.getFailedLogins();
+    }
+
+    private void assertReadFails(UserService userService, long id) {
+        try {
+            userService.read(id);
+            fail("access should not work");
+        } catch (Exception e) {
+            assertNotNull(e);
+        }
+    }
+
+    @Test
+    public void testAdminEntitlements() {
+        // 1. as anonymous, read all available entitlements
+        List<EntitlementTO> allEntitlements = entitlementService.getAllEntitlements();
+        assertNotNull(allEntitlements);
+        assertFalse(allEntitlements.isEmpty());
+
+        // 2. as admin, read own entitlements
+        List<EntitlementTO> adminEntitlements = entitlementService.getOwnEntitlements();
+
+        assertEquals(new HashSet<String>(CollectionWrapper.unwrap(allEntitlements)),
+                new HashSet<String>(CollectionWrapper.unwrap(adminEntitlements)));
+    }
+
+    @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");
+
+        authRoleTO = createRole(authRoleTO);
+        assertNotNull(authRoleTO);
+
+        String schemaName = "authTestSchema" + getUUIDString();
+
+        // 1. create a schema (as admin)
+        PlainSchemaTO schemaTO = new PlainSchemaTO();
+        schemaTO.setKey(schemaName);
+        schemaTO.setMandatoryCondition("false");
+        schemaTO.setType(AttrSchemaType.String);
+
+        PlainSchemaTO newPlainSchemaTO = createSchema(AttributableType.USER, SchemaType.PLAIN, schemaTO);
+        assertEquals(schemaTO, newPlainSchemaTO);
+
+        // 2. create an user with the role created above (as admin)
+        UserTO userTO = UserITCase.getUniqueSampleTO("auth@test.org");
+
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(authRoleTO.getKey());
+        AttrTO testAttrTO = new AttrTO();
+        testAttrTO.setSchema("testAttribute");
+        testAttrTO.getValues().add("a value");
+        membershipTO.getPlainAttrs().add(testAttrTO);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        assertNotNull(userTO);
+
+        // 3. read the schema created above (as admin) - success
+        schemaTO = schemaService.read(AttributableType.USER, SchemaType.PLAIN, schemaName);
+        assertNotNull(schemaTO);
+
+        // 4. read the schema created above (as user) - success
+        SchemaService schemaService2 = clientFactory.create(userTO.getUsername(), "password123").getService(
+                SchemaService.class);
+
+        schemaTO = schemaService2.read(AttributableType.USER, SchemaType.PLAIN, schemaName);
+        assertNotNull(schemaTO);
+
+        // 5. update the schema create above (as user) - failure
+        try {
+            schemaService2.update(AttributableType.ROLE, SchemaType.PLAIN, schemaName, schemaTO);
+            fail("Schemaupdate as user schould not work");
+        } catch (SyncopeClientException e) {
+            assertNotNull(e);
+            assertEquals(Response.Status.UNAUTHORIZED, e.getType().getResponseStatus());
+        } catch (AccessControlException e) {
+            // CXF Service will throw this exception
+            assertNotNull(e);
+        }
+
+        assertEquals(0, getFailedLogins(userService, userTO.getKey()));
+    }
+
+    @Test
+    public void testUserRead() {
+        UserTO userTO = UserITCase.getUniqueSampleTO("testuserread@test.org");
+
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(7L);
+        AttrTO testAttrTO = new AttrTO();
+        testAttrTO.setSchema("testAttribute");
+        testAttrTO.getValues().add("a value");
+        membershipTO.getPlainAttrs().add(testAttrTO);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        assertNotNull(userTO);
+
+        UserService userService2 = clientFactory.create(userTO.getUsername(), "password123").
+                getService(UserService.class);
+
+        UserTO readUserTO = userService2.read(1L);
+        assertNotNull(readUserTO);
+
+        UserService userService3 = clientFactory.create("verdi", ADMIN_PWD).getService(UserService.class);
+
+        SyncopeClientException exception = null;
+        try {
+            userService3.read(1L);
+            fail();
+        } catch (SyncopeClientException e) {
+            exception = e;
+        }
+        assertNotNull(exception);
+        assertEquals(ClientExceptionType.UnauthorizedRole, exception.getType());
+    }
+
+    @Test
+    public void testUserSearch() {
+        UserTO userTO = UserITCase.getUniqueSampleTO("testusersearch@test.org");
+
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(7L);
+        AttrTO testAttrTO = new AttrTO();
+        testAttrTO.setSchema("testAttribute");
+        testAttrTO.getValues().add("a value");
+        membershipTO.getPlainAttrs().add(testAttrTO);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        assertNotNull(userTO);
+
+        UserService userService2 = clientFactory.create(userTO.getUsername(), "password123").
+                getService(UserService.class);
+
+        PagedResult<UserTO> matchedUsers = userService2.search(
+                SyncopeClient.getUserSearchConditionBuilder().isNotNull("loginDate").query());
+        assertNotNull(matchedUsers);
+        assertFalse(matchedUsers.getResult().isEmpty());
+        Set<Long> userIds = new HashSet<Long>(matchedUsers.getResult().size());
+        for (UserTO user : matchedUsers.getResult()) {
+            userIds.add(user.getKey());
+        }
+        assertTrue(userIds.contains(1L));
+
+        UserService userService3 = clientFactory.create("verdi", "password").getService(UserService.class);
+
+        matchedUsers = userService3.search(
+                SyncopeClient.getUserSearchConditionBuilder().isNotNull("loginDate").query());
+        assertNotNull(matchedUsers);
+
+        userIds = new HashSet<>(matchedUsers.getResult().size());
+
+        for (UserTO user : matchedUsers.getResult()) {
+            userIds.add(user.getKey());
+        }
+        assertFalse(userIds.contains(1L));
+    }
+
+    @Test
+    public void checkFailedLogins() {
+        UserTO userTO = UserITCase.getUniqueSampleTO("checkFailedLogin@syncope.apache.org");
+
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(7L);
+        AttrTO testAttrTO = new AttrTO();
+        testAttrTO.setSchema("testAttribute");
+        testAttrTO.getValues().add("a value");
+        membershipTO.getPlainAttrs().add(testAttrTO);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        assertNotNull(userTO);
+        long userId = userTO.getKey();
+
+        UserService userService2 = clientFactory.create(userTO.getUsername(), "password123").getService(
+                UserService.class);
+        assertEquals(0, getFailedLogins(userService2, userId));
+
+        // authentications failed ...
+        UserService userService3 = clientFactory.create(userTO.getUsername(), "wrongpwd1").getService(
+                UserService.class);
+        assertReadFails(userService3, userId);
+        assertReadFails(userService3, userId);
+
+        assertEquals(2, getFailedLogins(userService, userId));
+
+        UserService userService4 = clientFactory.create(userTO.getUsername(), "password123").getService(
+                UserService.class);
+        assertEquals(0, getFailedLogins(userService4, userId));
+    }
+
+    @Test
+    public void checkUserSuspension() {
+        UserTO userTO = UserITCase.getUniqueSampleTO("checkSuspension@syncope.apache.org");
+
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(7L);
+        AttrTO testAttrTO = new AttrTO();
+        testAttrTO.setSchema("testAttribute");
+        testAttrTO.getValues().add("a value");
+        membershipTO.getPlainAttrs().add(testAttrTO);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        long userId = userTO.getKey();
+        assertNotNull(userTO);
+
+        UserService userService2 = clientFactory.create(userTO.getUsername(), "password123").
+                getService(UserService.class);
+        assertEquals(0, getFailedLogins(userService2, userId));
+
+        // authentications failed ...
+        UserService userService3 = clientFactory.create(userTO.getUsername(), "wrongpwd1").
+                getService(UserService.class);
+        assertReadFails(userService3, userId);
+        assertReadFails(userService3, userId);
+        assertReadFails(userService3, userId);
+
+        assertEquals(3, getFailedLogins(userService, userId));
+
+        // last authentication before suspension
+        assertReadFails(userService3, userId);
+
+        userTO = userService.read(userTO.getKey());
+        assertNotNull(userTO);
+        assertNotNull(userTO.getFailedLogins());
+        assertEquals(3, userTO.getFailedLogins(), 0);
+        assertEquals("suspended", userTO.getStatus());
+
+        // Access with correct credentials should fail as user is suspended
+        userService2 = clientFactory.create(userTO.getUsername(), "password123").getService(UserService.class);
+        assertReadFails(userService2, userId);
+
+        StatusMod reactivate = new StatusMod();
+        reactivate.setType(StatusMod.ModType.REACTIVATE);
+        userTO = userService.status(userTO.getKey(), reactivate).readEntity(UserTO.class);
+        assertNotNull(userTO);
+        assertEquals("active", userTO.getStatus());
+
+        userService2 = clientFactory.create(userTO.getUsername(), "password123").getService(UserService.class);
+        assertEquals(0, getFailedLogins(userService2, userId));
+    }
+
+    @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");
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(childRole.getKey());
+        role1Admin.getMemberships().add(membershipTO);
+
+        role1Admin = createUser(role1Admin);
+        assertNotNull(role1Admin);
+
+        UserService userService2 = clientFactory.create(role1Admin.getUsername(), "password").getService(
+                UserService.class);
+
+        // User with role 1, created by user with child role created above
+        UserTO role1User = UserITCase.getUniqueSampleTO("syncope48user@apache.org");
+        membershipTO = new MembershipTO();
+        membershipTO.setRoleId(1L);
+        role1User.getMemberships().add(membershipTO);
+
+        Response response = userService2.create(role1User, true);
+        assertNotNull(response);
+        role1User = response.readEntity(UserTO.class);
+        assertNotNull(role1User);
+    }
+
+    @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)
+        UserTO userTO = UserITCase.getUniqueSampleTO("createWithReject@syncope.apache.org");
+        MembershipTO membershipTO = new MembershipTO();
+        membershipTO.setRoleId(9L);
+        userTO.getMemberships().add(membershipTO);
+
+        userTO = createUser(userTO);
+        assertNotNull(userTO);
+        assertEquals("createApproval", userTO.getStatus());
+
+        // 2. try to authenticate: fail
+        EntitlementService myEntitlementService = clientFactory.create(userTO.getUsername(), "password123").
+                getService(EntitlementService.class);
+        try {
+            myEntitlementService.getOwnEntitlements();
+            fail();
+        } catch (AccessControlException e) {
+            assertNotNull(e);
+        }
+
+        // 3. approve user
+        WorkflowFormTO form = userWorkflowService.getFormForUser(userTO.getKey());
+        form = userWorkflowService.claimForm(form.getTaskId());
+        Map<String, WorkflowFormPropertyTO> props = form.getPropertyMap();
+        props.get("approve").setValue(Boolean.TRUE.toString());
+        form.getProperties().clear();
+        form.getProperties().addAll(props.values());
+        userTO = userWorkflowService.submitForm(form);
+        assertNotNull(userTO);
+        assertEquals("active", userTO.getStatus());
+
+        // 4. try to authenticate again: success
+        assertNotNull(myEntitlementService.getOwnEntitlements());
+    }
+
+    @Test
+    public void issueSYNCOPE164() throws Exception {
+        // 1. create user with db resource
+        UserTO user = UserITCase.getUniqueSampleTO("syncope164@syncope.apache.org");
+        user.setPassword("password1");
+        user.getResources().add(RESOURCE_NAME_TESTDB);
+        user = createUser(user);
+        assertNotNull(user);
+
+        // 2. unlink the resource from the created user
+        assertNotNull(userService.bulkDeassociation(user.getKey(),
+                ResourceDeassociationActionType.UNLINK,
+                CollectionWrapper.wrap(RESOURCE_NAME_TESTDB, ResourceName.class)).
+                readEntity(BulkActionResult.class));
+
+        // 3. change password on Syncope
+        UserMod userMod = new UserMod();
+        userMod.setKey(user.getKey());
+        userMod.setPassword("password2");
+        user = updateUser(userMod);
+        assertNotNull(user);
+
+        // 4. check that the db resource has still the initial password value
+        final JdbcTemplate jdbcTemplate = new JdbcTemplate(testDataSource);
+        String value = jdbcTemplate.queryForObject(
+                "SELECT PASSWORD FROM test WHERE ID=?", String.class, user.getUsername());
+        assertEquals(Encryptor.getInstance().encode("password1", CipherAlgorithm.SHA1), value.toUpperCase());
+
+        // 5. successfully authenticate with old (on db resource) and new (on internal storage) password values
+        user = clientFactory.create(user.getUsername(), "password1").getService(UserSelfService.class).read();
+        assertNotNull(user);
+        user = clientFactory.create(user.getUsername(), "password2").getService(UserSelfService.class).read();
+        assertNotNull(user);
+    }
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
new file mode 100644
index 0000000..47cad19
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelDetector.java
@@ -0,0 +1,32 @@
+/*
+ * 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 org.apache.syncope.common.rest.api.service.SyncopeService;
+
+public class CamelDetector {
+
+    public static boolean isCamelEnabledForUsers(final SyncopeService syncopeService) {
+        return syncopeService.info().getUserProvisioningManager().indexOf("Camel") != -1;
+    }
+
+    public static boolean isCamelEnabledForRoles(final SyncopeService syncopeService) {
+        return syncopeService.info().getRoleProvisioningManager().indexOf("Camel") != -1;
+    }
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
new file mode 100644
index 0000000..1b3e91d
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/CamelRouteITCase.java
@@ -0,0 +1,163 @@
+/*
+ * 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.assertNotNull;
+
+import java.util.List;
+import org.apache.syncope.common.lib.to.CamelRouteTO;
+import org.apache.syncope.common.lib.to.PlainSchemaTO;
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.common.lib.types.AttrSchemaType;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.SchemaType;
+import org.apache.syncope.common.lib.types.SubjectType;
+import org.junit.Assume;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class CamelRouteITCase extends AbstractITCase {
+
+    @Test
+    public void userRoutes() {
+        Assume.assumeTrue(CamelDetector.isCamelEnabledForUsers(syncopeService));
+
+        List<CamelRouteTO> userRoutes = camelRouteService.list(SubjectType.USER);
+        assertNotNull(userRoutes);
+        assertEquals(15, userRoutes.size());
+        for (CamelRouteTO route : userRoutes) {
+            assertNotNull(route.getContent());
+        }
+    }
+
+    @Test
+    public void roleRoutes() {
+        Assume.assumeTrue(CamelDetector.isCamelEnabledForRoles(syncopeService));
+
+        List<CamelRouteTO> roleRoutes = camelRouteService.list(SubjectType.ROLE);
+        assertNotNull(roleRoutes);
+        assertEquals(7, roleRoutes.size());
+        for (CamelRouteTO route : roleRoutes) {
+            assertNotNull(route.getContent());
+        }
+    }
+
+    private CamelRouteTO doUpdate(final String key, String content) {
+        CamelRouteTO route = camelRouteService.read(key);
+        route.setContent(content);
+        camelRouteService.update(route.getKey(), route);
+        //getting new route definition
+        return camelRouteService.read(key);
+    }
+
+    @Test
+    public void update() {
+        Assume.assumeTrue(CamelDetector.isCamelEnabledForUsers(syncopeService));
+
+        CamelRouteTO oldRoute = camelRouteService.read("createUser");
+        assertNotNull(oldRoute);
+        String routeContent = "<route id=\"createUser\">\n"
+                + "  <from uri=\"direct:createUser\"/>\n"
+                + "  <setProperty propertyName=\"actual\">\n"
+                + "    <simple>${body}</simple>\n"
+                + "  </setProperty>\n"
+                + "  <doTry>\n"
+                + "    <bean ref=\"uwfAdapter\" method=\"create(${body},${property.disablePwdPolicyCheck},\n"
+                + "                             ${property.enabled},${property.storePassword})\"/>\n"
+                + "    <process ref=\"userCreateProcessor\" />\n"
+                + "    <to uri=\"direct:createPort\"/>\n"
+                + "    <to uri=\"log:myLog\"/>\n"
+                + "    <doCatch>        \n"
+                + "      <exception>java.lang.RuntimeException</exception>\n"
+                + "      <handled>\n"
+                + "        <constant>false</constant>\n"
+                + "      </handled>\n"
+                + "      <to uri=\"direct:createPort\"/>\n"
+                + "    </doCatch>\n"
+                + "  </doTry>\n"
+                + "</route>";
+        try {
+            CamelRouteTO route = doUpdate("createUser", routeContent);
+            assertEquals(routeContent, route.getContent());
+        } finally {
+            doUpdate(oldRoute.getKey(), oldRoute.getContent());
+        }
+    }
+
+    @Test
+    public void scriptingUpdate() {
+        Assume.assumeTrue(CamelDetector.isCamelEnabledForUsers(syncopeService));
+
+        CamelRouteTO oldRoute = camelRouteService.read("createUser");
+        //updating route content including new attribute management
+        String routeContent = "<route id=\"createUser\">\n"
+                + "  <from uri=\"direct:createUser\"/>\n"
+                + "  <setProperty propertyName=\"actual\">\n"
+                + "    <simple>${body}</simple>\n"
+                + "  </setProperty>\n"
+                + "  <setBody>\n"
+                + "   <groovy>\n"
+                + "       request.body.getPlainAttrs().get(3).getValues().set(0,\"true\")\n"
+                + "       return request.body\n"
+                + "   </groovy>\n"
+                + "  </setBody>\n"
+                + "  <doTry>\n"
+                + "      <bean ref=\"uwfAdapter\" method=\"create(${body},${property.disablePwdPolicyCheck},\n"
+                + "                            ${property.enabled},${property.storePassword})\"/>\n"
+                + "      <process ref=\"userCreateProcessor\" />\n"
+                + "      <to uri=\"direct:createPort\"/>\n"
+                + "      <doCatch>        \n"
+                + "      <exception>java.lang.RuntimeException</exception>\n"
+                + "          <handled>\n"
+                + "           <constant>false</constant>\n"
+                + "          </handled>\n"
+                + "      <to uri=\"direct:createPort\"/>\n"
+                + "      </doCatch>\n"
+                + "   </doTry>\n"
+                + "</route>";
+        try {
+            doUpdate("createUser", routeContent);
+
+            //creating new schema attribute for user
+            PlainSchemaTO schemaTO = new PlainSchemaTO();
+            schemaTO.setKey("camelAttribute");
+            schemaTO.setType(AttrSchemaType.String);
+            createSchema(AttributableType.USER, SchemaType.PLAIN, schemaTO);
+
+            UserTO userTO = new UserTO();
+            String userId = getUUIDString() + "camelUser@syncope.apache.org";
+            userTO.setUsername(userId);
+            userTO.setPassword("password");
+            userTO.getPlainAttrs().add(attrTO("userId", userId));
+            userTO.getPlainAttrs().add(attrTO("fullname", userId));
+            userTO.getPlainAttrs().add(attrTO("surname", userId));
+            userTO.getPlainAttrs().add(attrTO("camelAttribute", "false"));
+
+            userTO = createUser(userTO);
+            assertNotNull(userTO);
+            assertEquals("true", userTO.getPlainAttrs().get(3).getValues().get(0));
+        } finally {
+            doUpdate(oldRoute.getKey(), oldRoute.getContent());
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
new file mode 100644
index 0000000..27fb19b
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConfigurationITCase.java
@@ -0,0 +1,245 @@
+/*
+ * 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.apache.commons.lang3.StringUtils.isEmpty;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.List;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.syncope.common.lib.SyncopeClientException;
+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.types.AttrSchemaType;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.ClientExceptionType;
+import org.apache.syncope.common.lib.types.EntityViolationType;
+import org.apache.syncope.common.lib.types.SchemaType;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class ConfigurationITCase extends AbstractITCase {
+
+    @Test
+    public void create() {
+        PlainSchemaTO testKey = new PlainSchemaTO();
+        testKey.setKey("testKey");
+        testKey.setType(AttrSchemaType.String);
+        createSchema(AttributableType.CONFIGURATION, SchemaType.PLAIN, testKey);
+
+        AttrTO conf = new AttrTO();
+        conf.setSchema("testKey");
+        conf.getValues().add("testValue");
+
+        configurationService.set(conf.getSchema(), conf);
+
+        AttrTO actual = configurationService.read(conf.getSchema());
+        assertEquals(actual, conf);
+    }
+
+    @Test
+    public void delete() throws UnsupportedEncodingException {
+        try {
+            configurationService.delete("nonExistent");
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+        }
+
+        AttrTO tokenLength = configurationService.read("token.length");
+
+        configurationService.delete("token.length");
+        try {
+            configurationService.read("token.length");
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+        }
+
+        configurationService.set(tokenLength.getSchema(), tokenLength);
+
+        AttrTO actual = configurationService.read(tokenLength.getSchema());
+        assertEquals(actual, tokenLength);
+    }
+
+    @Test
+    public void list() {
+        ConfTO wholeConf = configurationService.list();
+        assertNotNull(wholeConf);
+        for (AttrTO conf : wholeConf.getPlainAttrs()) {
+            assertNotNull(conf);
+        }
+    }
+
+    @Test
+    public void read() {
+        AttrTO conf = configurationService.read("token.expireTime");
+        assertNotNull(conf);
+    }
+
+    @Test
+    public void update() {
+        AttrTO expireTime = configurationService.read("token.expireTime");
+        int value = Integer.parseInt(expireTime.getValues().get(0));
+        value++;
+        expireTime.getValues().set(0, value + "");
+
+        configurationService.set(expireTime.getSchema(), expireTime);
+
+        AttrTO newConfigurationTO = configurationService.read(expireTime.getSchema());
+        assertEquals(expireTime, newConfigurationTO);
+    }
+
+    @Test
+    public void dbExport() throws IOException {
+        Response response = configurationService.export();
+        assertNotNull(response);
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatusInfo().getStatusCode());
+        assertTrue(response.getMediaType().toString().startsWith(MediaType.TEXT_XML));
+        String contentDisposition = response.getHeaderString(HttpHeaders.CONTENT_DISPOSITION);
+        assertNotNull(contentDisposition);
+
+        Object entity = response.getEntity();
+        assertTrue(entity instanceof InputStream);
+        String configExport = IOUtils.toString((InputStream) entity, SyncopeConstants.DEFAULT_ENCODING);
+        assertFalse(configExport.isEmpty());
+        assertTrue(configExport.length() > 1000);
+    }
+
+    @Test
+    public void issueSYNCOPE418() {
+        PlainSchemaTO failing = new PlainSchemaTO();
+        failing.setKey("http://schemas.examples.org/security/authorization/organizationUnit");
+        failing.setType(AttrSchemaType.String);
+
+        try {
+            createSchema(AttributableType.CONFIGURATION, SchemaType.PLAIN, failing);
+            fail();
+        } catch (SyncopeClientException e) {
+            assertEquals(ClientExceptionType.InvalidPlainSchema, e.getType());
+
+            assertNotNull(e.getElements());
+            assertEquals(1, e.getElements().size());
+            assertTrue(e.getElements().iterator().next().contains(EntityViolationType.InvalidName.name()));
+        }
+    }
+
+    private static String[] substringsBetween(final String str, final String open, final String close) {
+        if (str == null || isEmpty(open) || isEmpty(close)) {
+            return null;
+        }
+        final int strLen = str.length();
+        if (strLen == 0) {
+            return ArrayUtils.EMPTY_STRING_ARRAY;
+        }
+        final int closeLen = close.length();
+        final int openLen = open.length();
+        final List<String> list = new ArrayList<>();
+        int pos = 0;
+        while (pos < strLen - closeLen) {
+            int start = StringUtils.indexOfIgnoreCase(str, open, pos);
+            if (start < 0) {
+                break;
+            }
+            start += openLen;
+            final int end = StringUtils.indexOfIgnoreCase(str, close, start);
+            if (end < 0) {
+                break;
+            }
+            list.add(str.substring(start, end));
+            pos = end + closeLen;
+        }
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.toArray(new String[list.size()]);
+    }
+
+    @Test
+    public void issueSYNCOPE629() throws IOException {
+        PlainSchemaTO membershipKey = new PlainSchemaTO();
+        membershipKey.setKey("membershipKey" + getUUIDString());
+        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);
+
+        RoleTO roleTO = new RoleTO();
+        roleTO.setName("aRole" + getUUIDString());
+        roleTO.getMPlainAttrTemplates().add(membershipKey.getKey());
+        roleTO.getRPlainAttrTemplates().add(roleKey.getKey());
+        roleTO = createRole(roleTO);
+
+        try {
+            Response response = configurationService.export();
+            assertNotNull(response);
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatusInfo().getStatusCode());
+            assertTrue(response.getMediaType().toString().startsWith(MediaType.TEXT_XML));
+            String contentDisposition = response.getHeaderString(HttpHeaders.CONTENT_DISPOSITION);
+            assertNotNull(contentDisposition);
+
+            Object entity = response.getEntity();
+            assertTrue(entity instanceof InputStream);
+            String configExport = IOUtils.toString((InputStream) entity, SyncopeConstants.DEFAULT_ENCODING);
+            assertFalse(configExport.isEmpty());
+            assertTrue(configExport.length() > 1000);
+
+            String[] result = substringsBetween(configExport, "<RPLAINATTRTEMPLATE", "/>");
+            assertNotNull(result);
+            boolean rattrExists = false;
+            for (String entry : result) {
+                if (entry.contains(roleKey.getKey())) {
+                    rattrExists = true;
+                }
+            }
+            assertTrue(rattrExists);
+
+            result = substringsBetween(configExport, "<MPLAINATTRTEMPLATE", "/>");
+            assertNotNull(result);
+            boolean mattrExists = false;
+            for (String entry : result) {
+                if (entry.contains(membershipKey.getKey())) {
+                    mattrExists = true;
+                }
+            }
+            assertTrue(mattrExists);
+        } finally {
+            deleteRole(roleTO.getKey());
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConnectorITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConnectorITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConnectorITCase.java
new file mode 100644
index 0000000..de54fd5
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConnectorITCase.java
@@ -0,0 +1,730 @@
+/*
+ * 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.util.ArrayList;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import javax.ws.rs.core.Response;
+import org.apache.commons.io.IOUtils;
+import org.apache.syncope.common.lib.SyncopeClientException;
+import org.apache.syncope.common.lib.to.BulkAction;
+import org.apache.syncope.common.lib.to.ConnBundleTO;
+import org.apache.syncope.common.lib.to.ConnIdObjectClassTO;
+import org.apache.syncope.common.lib.to.ConnInstanceTO;
+import org.apache.syncope.common.lib.to.ConnPoolConfTO;
+import org.apache.syncope.common.lib.to.MappingItemTO;
+import org.apache.syncope.common.lib.to.MappingTO;
+import org.apache.syncope.common.lib.to.PlainSchemaTO;
+import org.apache.syncope.common.lib.to.ResourceTO;
+import org.apache.syncope.common.lib.types.ConnConfPropSchema;
+import org.apache.syncope.common.lib.types.ConnConfProperty;
+import org.apache.syncope.common.lib.types.ConnectorCapability;
+import org.apache.syncope.common.lib.types.IntMappingType;
+import org.apache.syncope.common.rest.api.service.ConnectorService;
+import org.apache.syncope.common.rest.api.service.ResourceService;
+import org.identityconnectors.common.security.GuardedString;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class ConnectorITCase extends AbstractITCase {
+
+    private static String connectorServerLocation;
+
+    private static String connidSoapVersion;
+
+    private static String connidDbTableVersion;
+
+    private static String testJDBCURL;
+
+    @BeforeClass
+    public static void setUpConnIdBundles() throws IOException {
+        InputStream propStream = null;
+        try {
+            Properties props = new Properties();
+            propStream = ConnectorITCase.class.getResourceAsStream("/connid.properties");
+            props.load(propStream);
+
+            for (String location : props.getProperty("connid.locations").split(",")) {
+                if (!location.startsWith("file")) {
+                    connectorServerLocation = location;
+                }
+            }
+
+            connidSoapVersion = props.getProperty("connid.soap.version");
+            connidDbTableVersion = props.getProperty("connid.db.table.version");
+
+            testJDBCURL = props.getProperty("testdb.url");
+        } catch (Exception e) {
+            LOG.error("Could not load /connid.properties", e);
+        } finally {
+            IOUtils.closeQuietly(propStream);
+        }
+        assertNotNull(connectorServerLocation);
+        assertNotNull(connidSoapVersion);
+        assertNotNull(connidDbTableVersion);
+        assertNotNull(testJDBCURL);
+    }
+
+    @Test(expected = SyncopeClientException.class)
+    public void createWithException() {
+        ConnInstanceTO connectorTO = new ConnInstanceTO();
+
+        Response response = connectorService.create(connectorTO);
+        if (response.getStatusInfo().getStatusCode() != Response.Status.CREATED.getStatusCode()) {
+            throw (RuntimeException) clientFactory.getExceptionMapper().fromResponse(response);
+        }
+    }
+
+    @Test
+    public void create() {
+        ConnInstanceTO connectorTO = new ConnInstanceTO();
+        connectorTO.setLocation(connectorService.read(100L).getLocation());
+        connectorTO.setVersion(connidSoapVersion);
+        connectorTO.setConnectorName("net.tirasa.connid.bundles.soap.WebServiceConnector");
+        connectorTO.setBundleName("net.tirasa.connid.bundles.soap");
+        connectorTO.setDisplayName("Display name");
+        connectorTO.setConnRequestTimeout(15);
+
+        // set the connector configuration using PropertyTO
+        Set<ConnConfProperty> conf = new HashSet<>();
+
+        ConnConfPropSchema endpointSchema = new ConnConfPropSchema();
+        endpointSchema.setName("endpoint");
+        endpointSchema.setType(String.class.getName());
+        endpointSchema.setRequired(true);
+        ConnConfProperty endpoint = new ConnConfProperty();
+        endpoint.setSchema(endpointSchema);
+        endpoint.getValues().add("http://localhost:8888/wssample/services");
+        endpoint.getValues().add("Provisioning");
+        conf.add(endpoint);
+
+        ConnConfPropSchema servicenameSchema = new ConnConfPropSchema();
+        servicenameSchema.setName("servicename");
+        servicenameSchema.setType(String.class.getName());
+        servicenameSchema.setRequired(true);
+        ConnConfProperty servicename = new ConnConfProperty();
+        servicename.setSchema(servicenameSchema);
+        conf.add(servicename);
+
+        // set connector configuration
+        connectorTO.getConfiguration().addAll(conf);
+
+        // set connector capabilities
+        connectorTO.getCapabilities().add(ConnectorCapability.TWO_PHASES_CREATE);
+        connectorTO.getCapabilities().add(ConnectorCapability.ONE_PHASE_CREATE);
+        connectorTO.getCapabilities().add(ConnectorCapability.TWO_PHASES_UPDATE);
+
+        // set connector pool conf
+        ConnPoolConfTO cpc = new ConnPoolConfTO();
+        cpc.setMaxObjects(1534);
+        connectorTO.setPoolConf(cpc);
+
+        Response response = connectorService.create(connectorTO);
+        if (response.getStatusInfo().getStatusCode() != Response.Status.CREATED.getStatusCode()) {
+            throw (RuntimeException) clientFactory.getExceptionMapper().fromResponse(response);
+        }
+
+        ConnInstanceTO actual = getObject(
+                response.getLocation(), ConnectorService.class, ConnInstanceTO.class);
+        assertNotNull(actual);
+
+        assertEquals(actual.getBundleName(), connectorTO.getBundleName());
+        assertEquals(actual.getConnectorName(), connectorTO.getConnectorName());
+        assertEquals(actual.getVersion(), connectorTO.getVersion());
+        assertEquals("Display name", actual.getDisplayName());
+        assertEquals(Integer.valueOf(15), actual.getConnRequestTimeout());
+        assertEquals(connectorTO.getCapabilities(), actual.getCapabilities());
+        assertNotNull(actual.getPoolConf());
+        assertEquals(1534, actual.getPoolConf().getMaxObjects().intValue());
+        assertEquals(10, actual.getPoolConf().getMaxIdle().intValue());
+
+        Throwable t = null;
+
+        // check update
+        actual.getCapabilities().remove(ConnectorCapability.TWO_PHASES_UPDATE);
+        actual.getPoolConf().setMaxObjects(null);
+
+        try {
+            connectorService.update(actual.getKey(), actual);
+            actual = connectorService.read(actual.getKey());
+        } catch (SyncopeClientException e) {
+            LOG.error("update failed", e);
+            t = e;
+        }
+
+        assertNull(t);
+        assertNotNull(actual);
+        assertEquals(EnumSet.of(ConnectorCapability.ONE_PHASE_CREATE, ConnectorCapability.TWO_PHASES_CREATE),
+                actual.getCapabilities());
+        assertEquals(10, actual.getPoolConf().getMaxObjects().intValue());
+
+        // check also for the deletion of the created object
+        try {
+            connectorService.delete(actual.getKey());
+        } catch (SyncopeClientException e) {
+            LOG.error("delete failed", e);
+            t = e;
+        }
+
+        assertNull(t);
+
+        // check the non existence
+        try {
+            connectorService.read(actual.getKey());
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+        }
+    }
+
+    @Test
+    public void update() {
+        ConnInstanceTO connectorTO = new ConnInstanceTO();
+
+        // set connector instance id
+        connectorTO.setKey(103L);
+
+        // set connector version
+        connectorTO.setVersion(connidSoapVersion);
+
+        // set connector name
+        connectorTO.setConnectorName("net.tirasa.connid.bundles.soap.WebServiceConnector");
+
+        // set bundle name
+        connectorTO.setBundleName("net.tirasa.connid.bundles.soap");
+
+        connectorTO.setConnRequestTimeout(20);
+
+        // set the connector configuration using PropertyTO
+        Set<ConnConfProperty> conf = new HashSet<ConnConfProperty>();
+
+        ConnConfPropSchema endpointSchema = new ConnConfPropSchema();
+        endpointSchema.setName("endpoint");
+        endpointSchema.setType(String.class.getName());
+        endpointSchema.setRequired(true);
+        ConnConfProperty endpoint = new ConnConfProperty();
+        endpoint.setSchema(endpointSchema);
+        endpoint.getValues().add("http://localhost:8888/wssample/services");
+        conf.add(endpoint);
+
+        ConnConfPropSchema servicenameSchema = new ConnConfPropSchema();
+        servicenameSchema.setName("servicename");
+        servicenameSchema.setType(String.class.getName());
+        servicenameSchema.setRequired(true);
+        ConnConfProperty servicename = new ConnConfProperty();
+        servicename.setSchema(servicenameSchema);
+        servicename.getValues().add("Provisioning");
+        conf.add(servicename);
+
+        // set connector configuration
+        connectorTO.getConfiguration().addAll(conf);
+
+        connectorService.update(connectorTO.getKey(), connectorTO);
+        ConnInstanceTO actual = connectorService.read(connectorTO.getKey());
+
+        assertNotNull(actual);
+
+        actual = connectorService.read(actual.getKey());
+
+        assertNotNull(actual);
+        assertEquals(actual.getBundleName(), connectorTO.getBundleName());
+        assertEquals(actual.getConnectorName(), connectorTO.getConnectorName());
+        assertEquals(actual.getVersion(), connectorTO.getVersion());
+        assertEquals(Integer.valueOf(20), actual.getConnRequestTimeout());
+    }
+
+    private List<ResourceTO> filter(final List<ResourceTO> input, final Long connectorKey) {
+        List<ResourceTO> result = new ArrayList<>();
+
+        for (ResourceTO resource : input) {
+            if (connectorKey.equals(resource.getConnectorId())) {
+                result.add(resource);
+            }
+        }
+
+        return result;
+    }
+
+    @Test
+    public void issueSYNCOPE10() {
+        // ----------------------------------
+        // Copy resource and connector in order to create new objects.
+        // ----------------------------------
+        // Retrieve a connector instance template.
+        ConnInstanceTO connInstanceTO = connectorService.read(103L);
+        assertNotNull(connInstanceTO);
+
+        // check for resource
+        List<ResourceTO> resources = filter(resourceService.list(), 103L);
+        assertEquals(4, resources.size());
+
+        // Retrieve a resource TO template.
+        ResourceTO resourceTO = resources.get(0);
+
+        // Make it new.
+        resourceTO.setKey("newAbout103");
+
+        // Make it new.
+        connInstanceTO.setKey(0);
+        connInstanceTO.setDisplayName("newDisplayName" + getUUIDString());
+        // ----------------------------------
+
+        // ----------------------------------
+        // Create a new connector instance.
+        // ----------------------------------
+        Response response = connectorService.create(connInstanceTO);
+        if (response.getStatusInfo().getStatusCode() != Response.Status.CREATED.getStatusCode()) {
+            throw (RuntimeException) clientFactory.getExceptionMapper().fromResponse(response);
+        }
+
+        connInstanceTO = getObject(response.getLocation(), ConnectorService.class, ConnInstanceTO.class);
+        assertNotNull(connInstanceTO);
+        assertFalse(connInstanceTO.getCapabilities().contains(ConnectorCapability.AUTHENTICATE));
+
+        long connId = connInstanceTO.getKey();
+
+        // Link resourceTO to the new connector instance.
+        resourceTO.setConnectorId(connId);
+        // ----------------------------------
+
+        // ----------------------------------
+        // Check for connector instance update after resource creation.
+        // ----------------------------------
+        response = resourceService.create(resourceTO);
+        resourceTO = getObject(response.getLocation(), ResourceService.class, ResourceTO.class);
+
+        assertNotNull(resourceTO);
+
+        resources = filter(resourceService.list(), connId);
+        assertEquals(1, resources.size());
+        // ----------------------------------
+
+        // ----------------------------------
+        // Check for spring bean.
+        // ----------------------------------
+        ConnInstanceTO connInstanceBean = connectorService.readByResource(resourceTO.getKey());
+        assertNotNull(connInstanceBean);
+        assertFalse(connInstanceBean.getCapabilities().contains(ConnectorCapability.AUTHENTICATE));
+        // ----------------------------------
+
+        // ----------------------------------
+        // Check for spring bean update after connector instance update.
+        // ----------------------------------
+        connInstanceTO.getCapabilities().add(ConnectorCapability.AUTHENTICATE);
+
+        connectorService.update(connInstanceTO.getKey(), connInstanceTO);
+        ConnInstanceTO actual = connectorService.read(connInstanceTO.getKey());
+        assertNotNull(actual);
+        assertTrue(connInstanceTO.getCapabilities().contains(ConnectorCapability.AUTHENTICATE));
+
+        // check for spring bean update
+        connInstanceBean = connectorService.readByResource(resourceTO.getKey());
+        assertTrue(connInstanceBean.getCapabilities().contains(ConnectorCapability.AUTHENTICATE));
+        // ----------------------------------
+    }
+
+    @Test
+    public void deleteWithException() {
+        try {
+            connectorService.delete(0L);
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.NOT_FOUND, e.getType().getResponseStatus());
+        }
+    }
+
+    @Test
+    public void list() {
+        List<ConnInstanceTO> connectorInstanceTOs = connectorService.list(null);
+        assertNotNull(connectorInstanceTOs);
+        assertFalse(connectorInstanceTOs.isEmpty());
+        for (ConnInstanceTO instance : connectorInstanceTOs) {
+            assertNotNull(instance);
+        }
+    }
+
+    @Test
+    public void read() {
+        ConnInstanceTO connectorInstanceTO = connectorService.read(100L);
+        assertNotNull(connectorInstanceTO);
+    }
+
+    @Test
+    public void getBundles() {
+        List<ConnBundleTO> bundles = connectorService.getBundles(null);
+        assertNotNull(bundles);
+        assertFalse(bundles.isEmpty());
+        for (ConnBundleTO bundle : bundles) {
+            assertNotNull(bundle);
+        }
+    }
+
+    @Test
+    public void getConnectorConfiguration() {
+        List<ConnConfProperty> props = connectorService.getConfigurationProperties(104L);
+        assertNotNull(props);
+        assertFalse(props.isEmpty());
+    }
+
+    @Test
+    public void checkHiddenProperty() {
+        ConnInstanceTO connInstanceTO = connectorService.read(100L);
+
+        boolean check = false;
+
+        for (ConnConfProperty prop : connInstanceTO.getConfiguration()) {
+            if ("receiveTimeout".equals(prop.getSchema().getName())) {
+                check = true;
+            }
+        }
+        assertTrue(check);
+    }
+
+    @Test
+    public void checkSelectedLanguage() {
+        // 1. Check Italian
+        List<ConnInstanceTO> connectorInstanceTOs = connectorService.list("it");
+
+        Map<String, ConnConfProperty> instanceConfMap;
+        for (ConnInstanceTO instance : connectorInstanceTOs) {
+            if ("net.tirasa.connid.bundles.db.table".equals(instance.getBundleName())) {
+                instanceConfMap = instance.getConfigurationMap();
+                assertEquals("Utente", instanceConfMap.get("user").getSchema().getDisplayName());
+            }
+        }
+
+        // 2. Check English (default)
+        connectorInstanceTOs = connectorService.list(null);
+
+        for (ConnInstanceTO instance : connectorInstanceTOs) {
+            if ("net.tirasa.connid.bundles.db.table".equals(instance.getBundleName())) {
+                instanceConfMap = instance.getConfigurationMap();
+                assertEquals("User", instanceConfMap.get("user").getSchema().getDisplayName());
+            }
+        }
+    }
+
+    @Test
+    public void validate() {
+        ConnInstanceTO connectorTO = new ConnInstanceTO();
+        connectorTO.setLocation(connectorServerLocation);
+        connectorTO.setVersion(connidDbTableVersion);
+        connectorTO.setConnectorName("net.tirasa.connid.bundles.db.table.DatabaseTableConnector");
+        connectorTO.setBundleName("net.tirasa.connid.bundles.db.table");
+        connectorTO.setDisplayName("H2Test");
+
+        // set the connector configuration using PropertyTO
+        Set<ConnConfProperty> conf = new HashSet<ConnConfProperty>();
+
+        ConnConfPropSchema jdbcDriverSchema = new ConnConfPropSchema();
+        jdbcDriverSchema.setName("jdbcDriver");
+        jdbcDriverSchema.setType(String.class.getName());
+        jdbcDriverSchema.setRequired(true);
+        ConnConfProperty jdbcDriver = new ConnConfProperty();
+        jdbcDriver.setSchema(jdbcDriverSchema);
+        jdbcDriver.getValues().add("org.h2.Driver");
+        conf.add(jdbcDriver);
+
+        ConnConfPropSchema jdbcUrlTemplateSchema = new ConnConfPropSchema();
+        jdbcUrlTemplateSchema.setName("jdbcUrlTemplate");
+        jdbcUrlTemplateSchema.setType(String.class.getName());
+        jdbcUrlTemplateSchema.setRequired(true);
+        ConnConfProperty jdbcUrlTemplate = new ConnConfProperty();
+        jdbcUrlTemplate.setSchema(jdbcUrlTemplateSchema);
+        jdbcUrlTemplate.getValues().add(testJDBCURL);
+        conf.add(jdbcUrlTemplate);
+
+        ConnConfPropSchema userSchema = new ConnConfPropSchema();
+        userSchema.setName("user");
+        userSchema.setType(String.class.getName());
+        userSchema.setRequired(false);
+        ConnConfProperty user = new ConnConfProperty();
+        user.setSchema(userSchema);
+        user.getValues().add("sa");
+        conf.add(user);
+
+        ConnConfPropSchema passwordSchema = new ConnConfPropSchema();
+        passwordSchema.setName("password");
+        passwordSchema.setType(GuardedString.class.getName());
+        passwordSchema.setRequired(true);
+        ConnConfProperty password = new ConnConfProperty();
+        password.setSchema(passwordSchema);
+        password.getValues().add("sa");
+        conf.add(password);
+
+        ConnConfPropSchema tableSchema = new ConnConfPropSchema();
+        tableSchema.setName("table");
+        tableSchema.setType(String.class.getName());
+        tableSchema.setRequired(true);
+        ConnConfProperty table = new ConnConfProperty();
+        table.setSchema(tableSchema);
+        table.getValues().add("test");
+        conf.add(table);
+
+        ConnConfPropSchema keyColumnSchema = new ConnConfPropSchema();
+        keyColumnSchema.setName("keyColumn");
+        keyColumnSchema.setType(String.class.getName());
+        keyColumnSchema.setRequired(true);
+        ConnConfProperty keyColumn = new ConnConfProperty();
+        keyColumn.setSchema(keyColumnSchema);
+        keyColumn.getValues().add("id");
+        conf.add(keyColumn);
+
+        ConnConfPropSchema passwordColumnSchema = new ConnConfPropSchema();
+        passwordColumnSchema.setName("passwordColumn");
+        passwordColumnSchema.setType(String.class.getName());
+        passwordColumnSchema.setRequired(true);
+        ConnConfProperty passwordColumn = new ConnConfProperty();
+        passwordColumn.setSchema(passwordColumnSchema);
+        passwordColumn.getValues().add("password");
+        conf.add(passwordColumn);
+
+        // set connector configuration
+        connectorTO.getConfiguration().addAll(conf);
+
+        assertTrue(connectorService.check(connectorTO));
+
+        conf.remove(password);
+        password.getValues().clear();
+        password.getValues().add("password");
+        conf.add(password);
+
+        assertFalse(connectorService.check(connectorTO));
+    }
+
+    @Test
+    public void getSchemaNames() {
+        ConnInstanceTO conn = connectorService.read(101L);
+
+        List<PlainSchemaTO> schemaNames = connectorService.getSchemaNames(conn.getKey(), conn, true);
+        assertNotNull(schemaNames);
+        assertFalse(schemaNames.isEmpty());
+        assertNotNull(schemaNames.get(0).getKey());
+        assertNull(schemaNames.get(0).getEnumerationValues());
+
+        schemaNames = connectorService.getSchemaNames(conn.getKey(), conn, false);
+
+        assertNotNull(schemaNames);
+        assertEquals(0, schemaNames.size());
+
+        conn = connectorService.read(104L);
+
+        // to be used with overridden properties
+        conn.getConfiguration().clear();
+
+        schemaNames = connectorService.getSchemaNames(conn.getKey(), conn, true);
+        assertNotNull(schemaNames);
+        assertFalse(schemaNames.isEmpty());
+    }
+
+    @Test
+    public void getSupportedObjectClasses() {
+        ConnInstanceTO ldap = connectorService.read(105L);
+        assertNotNull(ldap);
+
+        List<ConnIdObjectClassTO> objectClasses = connectorService.getSupportedObjectClasses(ldap.getKey(), ldap);
+        assertNotNull(objectClasses);
+        assertEquals(2, objectClasses.size());
+        assertTrue(objectClasses.contains(ConnIdObjectClassTO.ACCOUNT));
+        assertTrue(objectClasses.contains(ConnIdObjectClassTO.GROUP));
+
+        ConnInstanceTO csv = connectorService.read(104L);
+        assertNotNull(csv);
+
+        objectClasses = connectorService.getSupportedObjectClasses(csv.getKey(), csv);
+        assertNotNull(objectClasses);
+        assertEquals(1, objectClasses.size());
+        assertTrue(objectClasses.contains(ConnIdObjectClassTO.ACCOUNT));
+    }
+
+    @Test
+    public void issueSYNCOPE112() {
+        // ----------------------------------------
+        // Create a new connector
+        // ----------------------------------------
+        ConnInstanceTO connectorTO = new ConnInstanceTO();
+
+        connectorTO.setLocation(connectorService.read(100L).getLocation());
+
+        // set connector version
+        connectorTO.setVersion(connidSoapVersion);
+
+        // set connector name
+        connectorTO.setConnectorName("net.tirasa.connid.bundles.soap.WebServiceConnector");
+
+        // set bundle name
+        connectorTO.setBundleName("net.tirasa.connid.bundles.soap");
+
+        // set display name
+        connectorTO.setDisplayName("WSSoap");
+
+        // set the connector configuration using PropertyTO
+        Set<ConnConfProperty> conf = new HashSet<ConnConfProperty>();
+
+        ConnConfPropSchema userSchema = new ConnConfPropSchema();
+        userSchema.setName("endpoint");
+        userSchema.setType(String.class.getName());
+        userSchema.setRequired(true);
+        ConnConfProperty endpoint = new ConnConfProperty();
+        endpoint.setSchema(userSchema);
+        endpoint.getValues().add("http://localhost:9080/does_not_work");
+        endpoint.setOverridable(true);
+
+        ConnConfPropSchema keyColumnSchema = new ConnConfPropSchema();
+        keyColumnSchema.setName("servicename");
+        keyColumnSchema.setType(String.class.getName());
+        keyColumnSchema.setRequired(true);
+        ConnConfProperty servicename = new ConnConfProperty();
+        servicename.setSchema(keyColumnSchema);
+        servicename.getValues().add("net.tirasa.connid.bundles.soap.provisioning.interfaces.Provisioning");
+        servicename.setOverridable(false);
+
+        conf.add(endpoint);
+        conf.add(servicename);
+
+        // set connector configuration
+        connectorTO.getConfiguration().addAll(conf);
+
+        try {
+            assertFalse(connectorService.check(connectorTO));
+
+            Response response = connectorService.create(connectorTO);
+            if (response.getStatusInfo().getStatusCode() != Response.Status.CREATED.getStatusCode()) {
+                throw (RuntimeException) clientFactory.getExceptionMapper().fromResponse(response);
+            }
+
+            connectorTO = getObject(response.getLocation(), ConnectorService.class, ConnInstanceTO.class);
+            assertNotNull(connectorTO);
+            // ----------------------------------------
+
+            // ----------------------------------------
+            // create a resourceTO
+            // ----------------------------------------
+            String resourceName = "checkForPropOverriding";
+            ResourceTO resourceTO = new ResourceTO();
+
+            resourceTO.setKey(resourceName);
+            resourceTO.setConnectorId(connectorTO.getKey());
+
+            conf = new HashSet<ConnConfProperty>();
+            endpoint.getValues().clear();
+            endpoint.getValues().add("http://localhost:9080/wssample/services/provisioning");
+            conf.add(endpoint);
+
+            resourceTO.getConnConfProperties().addAll(conf);
+
+            MappingTO mapping = new MappingTO();
+            resourceTO.setUmapping(mapping);
+
+            MappingItemTO mapItem = new MappingItemTO();
+            mapItem.setExtAttrName("uid");
+            mapItem.setIntAttrName("userId");
+            mapItem.setIntMappingType(IntMappingType.UserPlainSchema);
+            mapItem.setAccountid(true);
+            mapping.setAccountIdItem(mapItem);
+            // ----------------------------------------
+
+            // ----------------------------------------
+            // Check connection without saving the resource ....
+            // ----------------------------------------
+            assertTrue(resourceService.check(resourceTO));
+            // ----------------------------------------
+        } finally {
+            // Remove connector from db to make test re-runnable
+            connectorService.delete(connectorTO.getKey());
+        }
+    }
+
+    @Test
+    public void reload() {
+        connectorService.reload();
+    }
+
+    @Test
+    public void bulkAction() {
+        final BulkAction bulkAction = new BulkAction();
+        bulkAction.setOperation(BulkAction.Type.DELETE);
+
+        ConnInstanceTO conn = connectorService.read(101L);
+
+        conn.setKey(0);
+        conn.setDisplayName("forBulk1");
+
+        bulkAction.getTargets().add(String.valueOf(getObject(
+                connectorService.create(conn).getLocation(), ConnectorService.class, ConnInstanceTO.class).getKey()));
+
+        conn.setDisplayName("forBulk2");
+
+        bulkAction.getTargets().add(String.valueOf(getObject(
+                connectorService.create(conn).getLocation(), ConnectorService.class, ConnInstanceTO.class).getKey()));
+
+        Iterator<String> iter = bulkAction.getTargets().iterator();
+
+        assertNotNull(connectorService.read(Long.valueOf(iter.next())));
+        assertNotNull(connectorService.read(Long.valueOf(iter.next())));
+
+        connectorService.bulk(bulkAction);
+
+        iter = bulkAction.getTargets().iterator();
+
+        try {
+            connectorService.read(Long.valueOf(iter.next()));
+            fail();
+        } catch (SyncopeClientException e) {
+            assertNotNull(e);
+        }
+
+        try {
+            connectorService.read(Long.valueOf(iter.next()));
+            fail();
+        } catch (SyncopeClientException e) {
+            assertNotNull(e);
+        }
+    }
+
+    @Test
+    public void issueSYNCOPE605() {
+
+        ConnInstanceTO connectorInstanceTO = connectorService.read(103L);
+        assertTrue(connectorInstanceTO.getCapabilities().isEmpty());
+
+        connectorInstanceTO.getCapabilities().add(ConnectorCapability.SEARCH);
+        connectorService.update(connectorInstanceTO.getKey(), connectorInstanceTO);
+
+        ConnInstanceTO updatedCapabilities = connectorService.read(connectorInstanceTO.getKey());
+        assertNotNull(updatedCapabilities.getCapabilities());
+        assertTrue(updatedCapabilities.getCapabilities().size() == 1);
+    }
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
new file mode 100644
index 0000000..a5c14ad
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/DerSchemaITCase.java
@@ -0,0 +1,151 @@
+/*
+ * 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.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+import javax.ws.rs.core.Response;
+import org.apache.syncope.common.lib.SyncopeClientException;
+import org.apache.syncope.common.lib.to.DerSchemaTO;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.ClientExceptionType;
+import org.apache.syncope.common.lib.types.EntityViolationType;
+import org.apache.syncope.common.lib.types.SchemaType;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class DerSchemaITCase extends AbstractITCase {
+
+    @Test
+    public void list() {
+        List<DerSchemaTO> derivedSchemas = schemaService.list(AttributableType.USER, SchemaType.DERIVED);
+        assertFalse(derivedSchemas.isEmpty());
+        for (DerSchemaTO derivedSchemaTO : derivedSchemas) {
+            assertNotNull(derivedSchemaTO);
+        }
+    }
+
+    @Test
+    public void read() {
+        DerSchemaTO derivedSchemaTO = schemaService.read(AttributableType.USER, SchemaType.DERIVED,
+                "cn");
+        assertNotNull(derivedSchemaTO);
+    }
+
+    @Test
+    public void create() {
+        DerSchemaTO schema = new DerSchemaTO();
+        schema.setKey("derived");
+        schema.setExpression("derived_sx + '_' + derived_dx");
+
+        DerSchemaTO actual = createSchema(AttributableType.USER, SchemaType.DERIVED, schema);
+        assertNotNull(actual);
+
+        actual = schemaService.read(AttributableType.USER, SchemaType.DERIVED, actual.getKey());
+        assertNotNull(actual);
+        assertEquals(actual.getExpression(), "derived_sx + '_' + derived_dx");
+    }
+
+    @Test
+    public void delete() {
+        DerSchemaTO schema = schemaService.read(AttributableType.ROLE, SchemaType.DERIVED, "rderiveddata");
+        assertNotNull(schema);
+
+        schemaService.delete(AttributableType.ROLE, SchemaType.DERIVED, schema.getKey());
+
+        try {
+            schemaService.read(AttributableType.ROLE, 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);
+            assertNotNull(schema);
+        }
+    }
+
+    @Test
+    public void update() {
+        DerSchemaTO schema = schemaService.read(AttributableType.MEMBERSHIP, SchemaType.DERIVED,
+                "mderiveddata");
+        assertNotNull(schema);
+        assertEquals("mderived_sx + '-' + mderived_dx", schema.getExpression());
+        try {
+            schema.setExpression("mderived_sx + '.' + mderived_dx");
+
+            schemaService.update(AttributableType.MEMBERSHIP, SchemaType.DERIVED,
+                    schema.getKey(), schema);
+
+            schema = schemaService.read(AttributableType.MEMBERSHIP, SchemaType.DERIVED, "mderiveddata");
+            assertNotNull(schema);
+            assertEquals("mderived_sx + '.' + mderived_dx", schema.getExpression());
+        } finally {
+            // Set updated back to make test re-runnable
+            schema.setExpression("mderived_sx + '-' + mderived_dx");
+            schemaService.update(AttributableType.MEMBERSHIP, SchemaType.DERIVED,
+                    schema.getKey(), schema);
+        }
+    }
+
+    @Test
+    public void issueSYNCOPE323() {
+        DerSchemaTO actual = schemaService.read(AttributableType.ROLE, SchemaType.DERIVED, "rderiveddata");
+        assertNotNull(actual);
+
+        try {
+            createSchema(AttributableType.ROLE, SchemaType.DERIVED, actual);
+            fail();
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.CONFLICT, e.getType().getResponseStatus());
+            assertEquals(ClientExceptionType.EntityExists, e.getType());
+        }
+
+        actual.setKey(null);
+        try {
+            createSchema(AttributableType.ROLE, SchemaType.DERIVED, actual);
+            fail();
+        } catch (SyncopeClientException e) {
+            assertEquals(Response.Status.BAD_REQUEST, e.getType().getResponseStatus());
+            assertEquals(ClientExceptionType.RequiredValuesMissing, e.getType());
+        }
+    }
+
+    @Test
+    public void issueSYNCOPE418() {
+        DerSchemaTO schema = new DerSchemaTO();
+        schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit");
+        schema.setExpression("derived_sx + '_' + derived_dx");
+
+        try {
+            createSchema(AttributableType.ROLE, SchemaType.DERIVED, schema);
+            fail();
+        } catch (SyncopeClientException e) {
+            assertEquals(ClientExceptionType.InvalidDerSchema, e.getType());
+            assertTrue(e.getElements().iterator().next().contains(EntityViolationType.InvalidName.name()));
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
----------------------------------------------------------------------
diff --git a/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
new file mode 100644
index 0000000..7b5e845
--- /dev/null
+++ b/syncope620/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/LoggerITCase.java
@@ -0,0 +1,215 @@
+/*
+ * 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.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+
+import java.text.ParseException;
+import java.util.List;
+import org.apache.syncope.common.lib.to.EventCategoryTO;
+import org.apache.syncope.common.lib.to.LoggerTO;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.AuditElements;
+import org.apache.syncope.common.lib.types.AuditElements.EventCategoryType;
+import org.apache.syncope.common.lib.types.AuditLoggerName;
+import org.apache.syncope.common.lib.types.LoggerLevel;
+import org.apache.syncope.common.lib.types.LoggerType;
+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.UserLogic;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.JVM)
+public class LoggerITCase extends AbstractITCase {
+
+    @Test
+    public void listLogs() {
+        List<LoggerTO> loggers = loggerService.list(LoggerType.LOG);
+        assertNotNull(loggers);
+        assertFalse(loggers.isEmpty());
+        for (LoggerTO logger : loggers) {
+            assertNotNull(logger);
+        }
+    }
+
+    @Test
+    public void listAudits() throws ParseException {
+        List<LoggerTO> audits = loggerService.list(LoggerType.AUDIT);
+
+        assertNotNull(audits);
+        assertFalse(audits.isEmpty());
+        for (LoggerTO audit : audits) {
+            assertNotNull(AuditLoggerName.fromLoggerName(audit.getKey()));
+        }
+    }
+
+    @Test
+    public void setLevel() {
+        List<LoggerTO> loggers = loggerService.list(LoggerType.LOG);
+        assertNotNull(loggers);
+        int startSize = loggers.size();
+
+        LoggerTO logger = new LoggerTO();
+        logger.setKey("TEST");
+        logger.setLevel(LoggerLevel.INFO);
+        loggerService.update(LoggerType.LOG, logger.getKey(), logger);
+        logger = loggerService.read(LoggerType.LOG, logger.getKey());
+        assertNotNull(logger);
+        assertEquals(LoggerLevel.INFO, logger.getLevel());
+
+        loggers = loggerService.list(LoggerType.LOG);
+        assertNotNull(loggers);
+        assertEquals(startSize + 1, loggers.size());
+
+        // TEST Delete
+        loggerService.delete(LoggerType.LOG, "TEST");
+        loggers = loggerService.list(LoggerType.LOG);
+        assertNotNull(loggers);
+        assertEquals(startSize, loggers.size());
+    }
+
+    @Test
+    public void enableDisableAudit() {
+        AuditLoggerName auditLoggerName = new AuditLoggerName(
+                EventCategoryType.REST,
+                ReportLogic.class.getSimpleName(),
+                null,
+                "deleteExecution",
+                AuditElements.Result.FAILURE);
+
+        List<AuditLoggerName> audits = CollectionWrapper.wrapLogger(loggerService.list(LoggerType.AUDIT));
+        assertNotNull(audits);
+        assertFalse(audits.contains(auditLoggerName));
+
+        LoggerTO loggerTO = new LoggerTO();
+        String name = auditLoggerName.toLoggerName();
+        loggerTO.setKey(name);
+        loggerTO.setLevel(LoggerLevel.DEBUG);
+        loggerService.update(LoggerType.AUDIT, name, loggerTO);
+
+        audits = CollectionWrapper.wrapLogger(loggerService.list(LoggerType.AUDIT));
+        assertNotNull(audits);
+        assertTrue(audits.contains(auditLoggerName));
+
+        loggerService.delete(LoggerType.AUDIT, auditLoggerName.toLoggerName());
+
+        audits = CollectionWrapper.wrapLogger(loggerService.list(LoggerType.AUDIT));
+        assertNotNull(audits);
+        assertFalse(audits.contains(auditLoggerName));
+    }
+
+    @Test
+    public void listAuditEvents() {
+        final List<EventCategoryTO> events = loggerService.events();
+
+        boolean found = false;
+
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (UserLogic.class.getSimpleName().equals(eventCategoryTO.getCategory())) {
+                assertEquals(EventCategoryType.REST, eventCategoryTO.getType());
+                assertTrue(eventCategoryTO.getEvents().contains("create"));
+                assertTrue(eventCategoryTO.getEvents().contains("list"));
+                assertFalse(eventCategoryTO.getEvents().contains("doCreate"));
+                assertFalse(eventCategoryTO.getEvents().contains("setStatusOnWfAdapter"));
+                assertFalse(eventCategoryTO.getEvents().contains("resolveReference"));
+                found = true;
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (RoleLogic.class.getSimpleName().equals(eventCategoryTO.getCategory())) {
+                assertEquals(EventCategoryType.REST, eventCategoryTO.getType());
+                assertTrue(eventCategoryTO.getEvents().contains("create"));
+                assertTrue(eventCategoryTO.getEvents().contains("list"));
+                assertFalse(eventCategoryTO.getEvents().contains("resolveReference"));
+                found = true;
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (ResourceLogic.class.getSimpleName().equals(eventCategoryTO.getCategory())) {
+                assertEquals(EventCategoryType.REST, eventCategoryTO.getType());
+                assertTrue(eventCategoryTO.getEvents().contains("create"));
+                assertTrue(eventCategoryTO.getEvents().contains("read"));
+                assertTrue(eventCategoryTO.getEvents().contains("delete"));
+                assertFalse(eventCategoryTO.getEvents().contains("resolveReference"));
+                found = true;
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (AttributableType.USER.name().toLowerCase().equals(eventCategoryTO.getCategory())) {
+                if (RESOURCE_NAME_LDAP.equals(eventCategoryTO.getSubcategory())
+                        && EventCategoryType.SYNCHRONIZATION == eventCategoryTO.getType()) {
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.CREATE.name().toLowerCase()));
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.UPDATE.name().toLowerCase()));
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.DELETE.name().toLowerCase()));
+                    found = true;
+                }
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (AttributableType.USER.name().toLowerCase().equals(eventCategoryTO.getCategory())) {
+                if (RESOURCE_NAME_CSV.equals(eventCategoryTO.getSubcategory())
+                        && EventCategoryType.PROPAGATION == eventCategoryTO.getType()) {
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.CREATE.name().toLowerCase()));
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.UPDATE.name().toLowerCase()));
+                    assertTrue(eventCategoryTO.getEvents().contains(ResourceOperation.DELETE.name().toLowerCase()));
+                    found = true;
+                }
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (EventCategoryType.TASK == eventCategoryTO.getType()
+                    && "SampleJob".equals(eventCategoryTO.getCategory())) {
+                found = true;
+            }
+        }
+        assertTrue(found);
+
+        found = false;
+        for (EventCategoryTO eventCategoryTO : events) {
+            if (EventCategoryType.TASK == eventCategoryTO.getType()
+                    && "SyncJob".equals(eventCategoryTO.getCategory())) {
+                found = true;
+            }
+        }
+        assertTrue(found);
+    }
+}


Mime
View raw message