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/06/11 16:17:55 UTC
[65/70] syncope git commit: [SYNCOPE-666] All done now
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/ResourceTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/ResourceTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/ResourceTest.java
new file mode 100644
index 0000000..d092f3d
--- /dev/null
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/ResourceTest.java
@@ -0,0 +1,306 @@
+/*
+ * 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.core.persistence.jpa.outer;
+
+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 java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import javax.persistence.EntityManager;
+import org.apache.syncope.common.lib.types.IntMappingType;
+import org.apache.syncope.common.lib.types.MappingPurpose;
+import org.apache.syncope.common.lib.types.TaskType;
+import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO;
+import org.apache.syncope.core.persistence.api.dao.ConnInstanceDAO;
+import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
+import org.apache.syncope.core.persistence.api.dao.PolicyDAO;
+import org.apache.syncope.core.persistence.api.dao.TaskDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.ConnInstance;
+import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource;
+import org.apache.syncope.core.persistence.api.entity.PasswordPolicy;
+import org.apache.syncope.core.persistence.api.entity.resource.Mapping;
+import org.apache.syncope.core.persistence.api.entity.resource.MappingItem;
+import org.apache.syncope.core.persistence.api.entity.resource.Provision;
+import org.apache.syncope.core.persistence.api.entity.task.PropagationTask;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.apache.syncope.core.persistence.jpa.entity.resource.JPAMappingItem;
+import org.identityconnectors.framework.common.objects.ObjectClass;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class ResourceTest extends AbstractTest {
+
+ @Autowired
+ private EntityManager entityManager;
+
+ @Autowired
+ private ExternalResourceDAO resourceDAO;
+
+ @Autowired
+ private ConnInstanceDAO connInstanceDAO;
+
+ @Autowired
+ private AnyTypeDAO anyTypeDAO;
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Autowired
+ private TaskDAO taskDAO;
+
+ @Autowired
+ private PolicyDAO policyDAO;
+
+ @Test
+ public void createWithPasswordPolicy() {
+ final String resourceName = "resourceWithPasswordPolicy";
+
+ PasswordPolicy policy = (PasswordPolicy) policyDAO.find(4L);
+ ExternalResource resource = entityFactory.newEntity(ExternalResource.class);
+ resource.setKey(resourceName);
+ resource.setPasswordPolicy(policy);
+
+ ConnInstance connector = connInstanceDAO.find(100L);
+ assertNotNull("connector not found", connector);
+ resource.setConnector(connector);
+
+ ExternalResource actual = resourceDAO.save(resource);
+ assertNotNull(actual);
+
+ actual = resourceDAO.find(actual.getKey());
+ assertNotNull(actual);
+ assertNotNull(actual.getPasswordPolicy());
+
+ resourceDAO.delete(resourceName);
+ assertNull(resourceDAO.find(resourceName));
+
+ assertNotNull(policyDAO.find(4L));
+ }
+
+ @Test
+ public void save() {
+ ExternalResource resource = entityFactory.newEntity(ExternalResource.class);
+ resource.setKey("ws-target-resource-save");
+
+ // specify the connector
+ ConnInstance connector = connInstanceDAO.find(100L);
+ assertNotNull("connector not found", connector);
+
+ resource.setConnector(connector);
+
+ Provision provision = entityFactory.newEntity(Provision.class);
+ provision.setAnyType(anyTypeDAO.findUser());
+ provision.setObjectClass(ObjectClass.ACCOUNT);
+ provision.setResource(resource);
+ resource.add(provision);
+
+ Mapping mapping = entityFactory.newEntity(Mapping.class);
+ mapping.setProvision(provision);
+ provision.setMapping(mapping);
+
+ // specify mappings
+ for (int i = 0; i < 3; i++) {
+ MappingItem item = entityFactory.newEntity(MappingItem.class);
+ item.setExtAttrName("test" + i);
+ item.setIntAttrName("nonexistent" + i);
+ item.setIntMappingType(IntMappingType.UserPlainSchema);
+ item.setMandatoryCondition("false");
+ item.setPurpose(MappingPurpose.SYNCHRONIZATION);
+ mapping.add(item);
+ item.setMapping(mapping);
+ }
+ MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class);
+ connObjectKey.setExtAttrName("username");
+ connObjectKey.setIntAttrName("username");
+ connObjectKey.setIntMappingType(IntMappingType.UserKey);
+ connObjectKey.setPurpose(MappingPurpose.PROPAGATION);
+ mapping.setConnObjectKeyItem(connObjectKey);
+ connObjectKey.setMapping(mapping);
+
+ // map a derived attribute
+ MappingItem derived = entityFactory.newEntity(MappingItem.class);
+ derived.setConnObjectKey(false);
+ derived.setExtAttrName("fullname");
+ derived.setIntAttrName("cn");
+ derived.setIntMappingType(IntMappingType.UserDerivedSchema);
+ derived.setPurpose(MappingPurpose.PROPAGATION);
+ mapping.add(derived);
+ derived.setMapping(mapping);
+
+ // save the resource
+ ExternalResource actual = resourceDAO.save(resource);
+ assertNotNull(actual);
+ assertNotNull(actual.getProvision(anyTypeDAO.findUser()).getMapping());
+
+ resourceDAO.flush();
+ resourceDAO.detach(actual);
+ connInstanceDAO.detach(connector);
+
+ // assign the new resource to an user
+ User user = userDAO.find(1L);
+ assertNotNull("user not found", user);
+
+ user.add(actual);
+
+ resourceDAO.flush();
+
+ // retrieve resource
+ resource = resourceDAO.find(actual.getKey());
+ assertNotNull(resource);
+ resourceDAO.refresh(resource);
+
+ // check connector
+ connector = connInstanceDAO.find(100L);
+ assertNotNull(connector);
+ assertNotNull(connector.getResources());
+
+ assertNotNull(resource.getConnector());
+ assertTrue(resource.getConnector().equals(connector));
+
+ // check mappings
+ List<? extends MappingItem> items = resource.getProvision(anyTypeDAO.findUser()).getMapping().getItems();
+ assertNotNull(items);
+ assertEquals(5, items.size());
+
+ // check user
+ user = userDAO.find(1L);
+ assertNotNull(user);
+ assertNotNull(user.getResources());
+ assertTrue(user.getResources().contains(actual));
+ }
+
+ @Test
+ public void delete() {
+ ExternalResource resource = resourceDAO.find("resource-testdb");
+ assertNotNull("find to delete did not work", resource);
+
+ // -------------------------------------
+ // Get originally associated connector
+ // -------------------------------------
+ ConnInstance connector = resource.getConnector();
+ assertNotNull(connector);
+ // -------------------------------------
+
+ // -------------------------------------
+ // Get originally associated users
+ // -------------------------------------
+ List<User> users = userDAO.findByResource(resource);
+ assertNotNull(users);
+
+ Set<Long> userIds = new HashSet<>();
+ for (User user : users) {
+ userIds.add(user.getKey());
+ }
+ // -------------------------------------
+
+ // Get tasks
+ List<PropagationTask> propagationTasks = taskDAO.findAll(resource, TaskType.PROPAGATION);
+ assertFalse(propagationTasks.isEmpty());
+
+ // delete resource
+ resourceDAO.delete(resource.getKey());
+
+ // close the transaction
+ resourceDAO.flush();
+
+ // resource must be removed
+ ExternalResource actual = resourceDAO.find("resource-testdb");
+ assertNull("delete did not work", actual);
+
+ // resource must be not referenced any more from users
+ for (Long id : userIds) {
+ User actualUser = userDAO.find(id);
+ assertNotNull(actualUser);
+ for (ExternalResource res : userDAO.findAllResources(actualUser)) {
+ assertFalse(res.getKey().equalsIgnoreCase(resource.getKey()));
+ }
+ }
+
+ // resource must be not referenced any more from the connector
+ ConnInstance actualConnector = connInstanceDAO.find(connector.getKey());
+ assertNotNull(actualConnector);
+ for (ExternalResource res : actualConnector.getResources()) {
+ assertFalse(res.getKey().equalsIgnoreCase(resource.getKey()));
+ }
+
+ // there must be no tasks
+ for (PropagationTask task : propagationTasks) {
+ assertNull(taskDAO.find(task.getKey()));
+ }
+ }
+
+ @Test
+ public void emptyMapping() {
+ ExternalResource ldap = resourceDAO.find("resource-ldap");
+ assertNotNull(ldap);
+ assertNotNull(ldap.getProvision(anyTypeDAO.findUser()).getMapping());
+ assertNotNull(ldap.getProvision(anyTypeDAO.findGroup()).getMapping());
+
+ List<? extends MappingItem> items = ldap.getProvision(anyTypeDAO.findGroup()).getMapping().getItems();
+ assertNotNull(items);
+ assertFalse(items.isEmpty());
+ List<Long> itemKeys = new ArrayList<>(items.size());
+ for (MappingItem item : items) {
+ itemKeys.add(item.getKey());
+ }
+
+ ldap.remove(ldap.getProvision(anyTypeDAO.findGroup()));
+
+ // need to avoid any class not defined in this Maven module
+ ldap.getPropagationActionsClassNames().clear();
+
+ resourceDAO.save(ldap);
+ resourceDAO.flush();
+
+ for (Long itemId : itemKeys) {
+ assertNull(entityManager.find(JPAMappingItem.class, itemId));
+ }
+ }
+
+ @Test
+ public void issue243() {
+ ExternalResource csv = resourceDAO.find("resource-csv");
+ assertNotNull(csv);
+
+ int origMapItems = csv.getProvision(anyTypeDAO.findUser()).getMapping().getItems().size();
+
+ MappingItem newMapItem = entityFactory.newEntity(MappingItem.class);
+ newMapItem.setIntMappingType(IntMappingType.Username);
+ newMapItem.setExtAttrName("TEST");
+ newMapItem.setPurpose(MappingPurpose.PROPAGATION);
+ csv.getProvision(anyTypeDAO.findUser()).getMapping().add(newMapItem);
+
+ resourceDAO.save(csv);
+ resourceDAO.flush();
+
+ csv = resourceDAO.find("resource-csv");
+ assertNotNull(csv);
+ assertEquals(origMapItems + 1, csv.getProvision(anyTypeDAO.findUser()).getMapping().getItems().size());
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/RoleTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/RoleTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/RoleTest.java
new file mode 100644
index 0000000..11b572c
--- /dev/null
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/RoleTest.java
@@ -0,0 +1,167 @@
+/*
+ * 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.core.persistence.jpa.outer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import javax.persistence.EntityManager;
+import javax.persistence.TypedQuery;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.Transformer;
+import org.apache.syncope.common.lib.types.AnyTypeKind;
+import org.apache.syncope.common.lib.types.Entitlement;
+import org.apache.syncope.core.persistence.api.dao.AnyTypeClassDAO;
+import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
+import org.apache.syncope.core.persistence.api.dao.RealmDAO;
+import org.apache.syncope.core.persistence.api.dao.RoleDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.user.DynRoleMembership;
+import org.apache.syncope.core.persistence.api.entity.Role;
+import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPADynRoleMembership;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class RoleTest extends AbstractTest {
+
+ @Autowired
+ private EntityManager entityManager;
+
+ @Autowired
+ private RoleDAO roleDAO;
+
+ @Autowired
+ private RealmDAO realmDAO;
+
+ @Autowired
+ private PlainSchemaDAO plainSchemaDAO;
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Autowired
+ private AnyTypeClassDAO anyTypeClassDAO;
+
+ /**
+ * Static copy of {@link org.apache.syncope.core.persistence.jpa.dao.JPAUserDAO} method with same signature:
+ * required for avoiding creating new transaction - good for general use case but bad for the way how
+ * this test class is architected.
+ */
+ private Collection<Role> findDynRoleMemberships(final User user) {
+ TypedQuery<Role> query = entityManager.createQuery(
+ "SELECT e.role FROM " + JPADynRoleMembership.class.getSimpleName()
+ + " e WHERE :user MEMBER OF e.users", Role.class);
+ query.setParameter("user", user);
+
+ return query.getResultList();
+ }
+
+ @Test
+ public void dynMembership() {
+ // 0. create user matching the condition below
+ User user = entityFactory.newEntity(User.class);
+ user.setUsername("username");
+ user.setRealm(realmDAO.find("/even/two"));
+ user.add(anyTypeClassDAO.find("other"));
+
+ UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class);
+ attr.setOwner(user);
+ attr.setSchema(plainSchemaDAO.find("cool"));
+ attr.add("true", anyUtilsFactory.getInstance(AnyTypeKind.USER));
+ user.add(attr);
+
+ user = userDAO.save(user);
+ Long newUserKey = user.getKey();
+ assertNotNull(newUserKey);
+
+ // 1. create role with dynamic membership
+ Role role = entityFactory.newEntity(Role.class);
+ role.setName("new");
+ role.addRealm(realmDAO.getRoot());
+ role.addRealm(realmDAO.find("/even/two"));
+ role.getEntitlements().add(Entitlement.LOG_LIST);
+ role.getEntitlements().add(Entitlement.LOG_SET_LEVEL);
+
+ DynRoleMembership dynMembership = entityFactory.newEntity(DynRoleMembership.class);
+ dynMembership.setFIQLCond("cool==true");
+ dynMembership.setRole(role);
+
+ role.setDynMembership(dynMembership);
+
+ Role actual = roleDAO.save(role);
+ assertNotNull(actual);
+
+ roleDAO.flush();
+
+ // 2. verify that dynamic membership is there
+ actual = roleDAO.find(actual.getKey());
+ assertNotNull(actual);
+ assertNotNull(actual.getDynMembership());
+ assertNotNull(actual.getDynMembership().getKey());
+ assertEquals(actual, actual.getDynMembership().getRole());
+
+ // 3. verify that expected users have the created role dynamically assigned
+ assertEquals(2, actual.getDynMembership().getMembers().size());
+ assertEquals(new HashSet<>(Arrays.asList(4L, newUserKey)),
+ CollectionUtils.collect(actual.getDynMembership().getMembers(), new Transformer<User, Long>() {
+
+ @Override
+ public Long transform(final User input) {
+ return input.getKey();
+ }
+ }, new HashSet<Long>()));
+
+ user = userDAO.find(4L);
+ assertNotNull(user);
+ Collection<Role> dynRoleMemberships = findDynRoleMemberships(user);
+ assertEquals(1, dynRoleMemberships.size());
+ assertTrue(dynRoleMemberships.contains(actual.getDynMembership().getRole()));
+
+ // 4. delete the new user and verify that dynamic membership was updated
+ userDAO.delete(newUserKey);
+
+ userDAO.flush();
+
+ actual = roleDAO.find(actual.getKey());
+ assertEquals(1, actual.getDynMembership().getMembers().size());
+ assertEquals(4L, actual.getDynMembership().getMembers().get(0).getKey(), 0);
+
+ // 5. delete role and verify that dynamic membership was also removed
+ Long dynMembershipKey = actual.getDynMembership().getKey();
+
+ roleDAO.delete(actual);
+
+ roleDAO.flush();
+
+ assertNull(entityManager.find(JPADynRoleMembership.class, dynMembershipKey));
+
+ dynRoleMemberships = findDynRoleMemberships(user);
+ assertTrue(dynRoleMemberships.isEmpty());
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/SecurityQuestionTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/SecurityQuestionTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/SecurityQuestionTest.java
new file mode 100644
index 0000000..0a966da
--- /dev/null
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/SecurityQuestionTest.java
@@ -0,0 +1,61 @@
+/*
+ * 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.core.persistence.jpa.outer;
+
+import static org.junit.Assert.assertNull;
+
+import org.apache.syncope.core.persistence.api.dao.SecurityQuestionDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class SecurityQuestionTest extends AbstractTest {
+
+ @Autowired
+ private SecurityQuestionDAO securityQuestionDAO;
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Test
+ public void test() {
+ User user = userDAO.find(4L);
+ assertNull(user.getSecurityQuestion());
+ assertNull(user.getSecurityAnswer());
+
+ user.setSecurityQuestion(securityQuestionDAO.find(1L));
+ user.setSecurityAnswer("Rossi");
+ userDAO.save(user);
+
+ userDAO.flush();
+
+ securityQuestionDAO.delete(1L);
+
+ userDAO.flush();
+
+ user = userDAO.find(4L);
+
+ assertNull(user.getSecurityQuestion());
+ assertNull(user.getSecurityAnswer());
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/TaskTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/TaskTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/TaskTest.java
new file mode 100644
index 0000000..f281fb4
--- /dev/null
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/TaskTest.java
@@ -0,0 +1,295 @@
+/*
+ * 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.core.persistence.jpa.outer;
+
+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 java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.common.lib.types.AnyTypeKind;
+import org.apache.syncope.common.lib.types.MatchingRule;
+import org.apache.syncope.common.lib.types.PropagationMode;
+import org.apache.syncope.common.lib.types.PropagationTaskExecStatus;
+import org.apache.syncope.common.lib.types.ResourceOperation;
+import org.apache.syncope.common.lib.types.TaskType;
+import org.apache.syncope.common.lib.types.UnmatchingRule;
+import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException;
+import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
+import org.apache.syncope.core.persistence.api.dao.TaskDAO;
+import org.apache.syncope.core.persistence.api.dao.TaskExecDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource;
+import org.apache.syncope.core.persistence.api.entity.task.PropagationTask;
+import org.apache.syncope.core.persistence.api.entity.task.PushTask;
+import org.apache.syncope.core.persistence.api.entity.task.SyncTask;
+import org.apache.syncope.core.persistence.api.entity.task.TaskExec;
+import org.apache.syncope.core.persistence.api.entity.task.AnyTemplate;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.apache.syncope.core.provisioning.api.sync.SyncActions;
+import org.identityconnectors.framework.common.objects.Attribute;
+import org.identityconnectors.framework.common.objects.AttributeBuilder;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class TaskTest extends AbstractTest {
+
+ @Autowired
+ private TaskDAO taskDAO;
+
+ @Autowired
+ private TaskExecDAO taskExecDAO;
+
+ @Autowired
+ private ExternalResourceDAO resourceDAO;
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Test
+ public void read() {
+ PropagationTask task = taskDAO.find(1L);
+ assertNotNull(task);
+
+ assertNotNull(task.getExecs());
+ assertFalse(task.getExecs().isEmpty());
+ assertEquals(1, task.getExecs().size());
+ }
+
+ @Test
+ public void save() {
+ ExternalResource resource = resourceDAO.find("ws-target-resource-1");
+ assertNotNull(resource);
+
+ User user = userDAO.find(2L);
+ assertNotNull(user);
+
+ PropagationTask task = entityFactory.newEntity(PropagationTask.class);
+ task.setResource(resource);
+ task.setAnyTypeKind(AnyTypeKind.USER);
+ task.setPropagationMode(PropagationMode.TWO_PHASES);
+ task.setPropagationOperation(ResourceOperation.CREATE);
+ task.setConnObjectKey("one@two.com");
+
+ Set<Attribute> attributes = new HashSet<>();
+ attributes.add(AttributeBuilder.build("testAttribute", "testValue1", "testValue2"));
+ attributes.add(AttributeBuilder.buildPassword("password".toCharArray()));
+ task.setAttributes(attributes);
+
+ task = taskDAO.save(task);
+ assertNotNull(task);
+
+ PropagationTask actual = taskDAO.find(task.getKey());
+ assertEquals(task, actual);
+
+ taskDAO.flush();
+
+ resource = resourceDAO.find("ws-target-resource-1");
+ assertTrue(taskDAO.findAll(resource, TaskType.PROPAGATION).contains(task));
+ }
+
+ @Test
+ public void addPropagationTaskExecution() {
+ PropagationTask task = taskDAO.find(1L);
+ assertNotNull(task);
+
+ int executionNumber = task.getExecs().size();
+
+ TaskExec execution = entityFactory.newEntity(TaskExec.class);
+ execution.setTask(task);
+ execution.setStatus(PropagationTaskExecStatus.CREATED.name());
+ task.addExec(execution);
+ execution.setStartDate(new Date());
+
+ taskDAO.save(task);
+ taskDAO.flush();
+
+ task = taskDAO.find(1L);
+ assertNotNull(task);
+
+ assertEquals(executionNumber + 1, task.getExecs().size());
+ }
+
+ @Test
+ public void addSyncTaskExecution() {
+ SyncTask task = taskDAO.find(4L);
+ assertNotNull(task);
+
+ int executionNumber = task.getExecs().size();
+
+ TaskExec execution = entityFactory.newEntity(TaskExec.class);
+ execution.setStatus("Text-free status");
+ execution.setTask(task);
+ task.addExec(execution);
+ execution.setMessage("A message");
+
+ taskDAO.save(task);
+ taskDAO.flush();
+
+ task = taskDAO.find(4L);
+ assertNotNull(task);
+
+ assertEquals(executionNumber + 1, task.getExecs().size());
+ }
+
+ @Test
+ public void addPushTaskExecution() {
+ PushTask task = taskDAO.find(13L);
+ assertNotNull(task);
+
+ int executionNumber = task.getExecs().size();
+
+ TaskExec execution = entityFactory.newEntity(TaskExec.class);
+ execution.setStatus("Text-free status");
+ execution.setTask(task);
+ task.addExec(execution);
+ execution.setMessage("A message");
+
+ taskDAO.save(task);
+ taskDAO.flush();
+
+ task = taskDAO.find(13L);
+ assertNotNull(task);
+
+ assertEquals(executionNumber + 1, task.getExecs().size());
+ }
+
+ @Test
+ public void deleteTask() {
+ taskDAO.delete(1L);
+
+ taskDAO.flush();
+
+ assertNull(taskDAO.find(1L));
+ assertNull(taskExecDAO.find(1L));
+ }
+
+ @Test
+ public void deleteTaskExecution() {
+ TaskExec execution = taskExecDAO.find(1L);
+ int executionNumber = execution.getTask().getExecs().size();
+
+ taskExecDAO.delete(1L);
+
+ taskExecDAO.flush();
+
+ assertNull(taskExecDAO.find(1L));
+
+ PropagationTask task = taskDAO.find(1L);
+ assertEquals(task.getExecs().size(), executionNumber - 1);
+ }
+
+ @Test
+ public void saveSyncTask() {
+ ExternalResource resource = resourceDAO.find("ws-target-resource-1");
+ assertNotNull(resource);
+
+ AnyTemplate template = entityFactory.newEntity(AnyTemplate.class);
+ template.set(new UserTO());
+
+ SyncTask task = entityFactory.newEntity(SyncTask.class);
+ task.setName("saveSyncTask");
+ task.setDescription("SyncTask description");
+ task.add(template);
+ task.setCronExpression("BLA BLA");
+ task.setMatchingRule(MatchingRule.UPDATE);
+ task.setUnmatchingRule(UnmatchingRule.PROVISION);
+
+ // this save() fails because of an invalid Cron Expression
+ InvalidEntityException exception = null;
+ try {
+ taskDAO.save(task);
+ } catch (InvalidEntityException e) {
+ exception = e;
+ }
+ assertNotNull(exception);
+
+ task.setCronExpression(null);
+ // this save() fails because a SyncTask requires a target resource
+ exception = null;
+ try {
+ taskDAO.save(task);
+ } catch (InvalidEntityException e) {
+ exception = e;
+ }
+ assertNotNull(exception);
+
+ task.setResource(resource);
+ task.getActionsClassNames().add(getClass().getName());
+
+ // this save() fails because jobActionsClassName does not implement
+ // the right interface
+ exception = null;
+ try {
+ taskDAO.save(task);
+ } catch (InvalidEntityException e) {
+ exception = e;
+ }
+ assertNotNull(exception);
+
+ task.getActionsClassNames().clear();
+ task.getActionsClassNames().add(SyncActions.class.getName());
+ // this save() finally works
+ task = taskDAO.save(task);
+ assertNotNull(task);
+
+ SyncTask actual = taskDAO.find(task.getKey());
+ assertEquals(task, actual);
+ }
+
+ @Test
+ public void issueSYNCOPE144() {
+ ExternalResource resource = resourceDAO.find("ws-target-resource-1");
+ assertNotNull(resource);
+
+ SyncTask task = entityFactory.newEntity(SyncTask.class);
+
+ task.setResource(resource);
+ task.setName("issueSYNCOPE144");
+ task.setDescription("issueSYNCOPE144 Description");
+ task.getActionsClassNames().add(SyncActions.class.getName());
+ task.setMatchingRule(MatchingRule.UPDATE);
+ task.setUnmatchingRule(UnmatchingRule.PROVISION);
+
+ task = taskDAO.save(task);
+ assertNotNull(task);
+
+ SyncTask actual = taskDAO.find(task.getKey());
+ assertEquals(task, actual);
+ assertEquals("issueSYNCOPE144", actual.getName());
+ assertEquals("issueSYNCOPE144 Description", actual.getDescription());
+
+ actual.setName("issueSYNCOPE144_2");
+ actual.setDescription("issueSYNCOPE144 Description_2");
+
+ actual = taskDAO.save(actual);
+ assertNotNull(actual);
+ assertEquals("issueSYNCOPE144_2", actual.getName());
+ assertEquals("issueSYNCOPE144 Description_2", actual.getDescription());
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/UserTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/UserTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/UserTest.java
new file mode 100644
index 0000000..b921cdc
--- /dev/null
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/outer/UserTest.java
@@ -0,0 +1,131 @@
+/*
+ * 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.core.persistence.jpa.outer;
+
+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 java.util.List;
+import org.apache.syncope.core.persistence.api.dao.AnyObjectDAO;
+import org.apache.syncope.core.persistence.api.dao.PlainAttrDAO;
+import org.apache.syncope.core.persistence.api.dao.PlainAttrValueDAO;
+import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
+import org.apache.syncope.core.persistence.api.dao.GroupDAO;
+import org.apache.syncope.core.persistence.api.dao.RelationshipTypeDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.user.UMembership;
+import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr;
+import org.apache.syncope.core.persistence.api.entity.user.UPlainAttrValue;
+import org.apache.syncope.core.persistence.api.entity.user.URelationship;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class UserTest extends AbstractTest {
+
+ @Autowired
+ private RelationshipTypeDAO relationshipTypeDAO;
+
+ @Autowired
+ private AnyObjectDAO anyObjectDAO;
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Autowired
+ private GroupDAO groupDAO;
+
+ @Autowired
+ private PlainSchemaDAO plainSchemaDAO;
+
+ @Autowired
+ private PlainAttrDAO plainAttrDAO;
+
+ @Autowired
+ private PlainAttrValueDAO plainAttrValueDAO;
+
+ @Test
+ public void delete() {
+ List<UMembership> memberships = groupDAO.findUMemberships(groupDAO.find(7L));
+ assertFalse(memberships.isEmpty());
+ List<URelationship> relationships = anyObjectDAO.findURelationships(anyObjectDAO.find(1L));
+ assertFalse(relationships.isEmpty());
+
+ userDAO.delete(4L);
+
+ userDAO.flush();
+
+ assertNull(userDAO.find(4L));
+ assertNull(plainAttrDAO.find(550L, UPlainAttr.class));
+ assertNull(plainAttrValueDAO.find(22L, UPlainAttrValue.class));
+ assertNotNull(plainSchemaDAO.find("loginDate"));
+
+ memberships = groupDAO.findUMemberships(groupDAO.find(7L));
+ assertTrue(memberships.isEmpty());
+ relationships = anyObjectDAO.findURelationships(anyObjectDAO.find(1L));
+ assertTrue(relationships.isEmpty());
+ }
+
+ @Test
+ public void ships() {
+ User user = userDAO.find(4L);
+ assertNotNull(user);
+ assertEquals(1, user.getMemberships().size());
+ assertEquals(7L, user.getMemberships().get(0).getRightEnd().getKey(), 0);
+
+ user.remove(user.getMemberships().get(0));
+
+ UMembership newM = entityFactory.newEntity(UMembership.class);
+ newM.setLeftEnd(user);
+ newM.setRightEnd(groupDAO.find(13L));
+ user.add(newM);
+
+ userDAO.save(user);
+
+ userDAO.flush();
+
+ user = userDAO.find(4L);
+ assertEquals(1, user.getMemberships().size());
+ assertEquals(13L, user.getMemberships().get(0).getRightEnd().getKey(), 0);
+ assertEquals(1, user.getRelationships().size());
+ assertEquals(1L, user.getRelationships().get(0).getRightEnd().getKey(), 0);
+
+ user.remove(user.getRelationships().get(0));
+
+ URelationship newR = entityFactory.newEntity(URelationship.class);
+ newR.setType(relationshipTypeDAO.find("neighborhood"));
+ newR.setLeftEnd(user);
+ newR.setRightEnd(anyObjectDAO.find(2L));
+ user.add(newR);
+
+ userDAO.save(user);
+
+ userDAO.flush();
+
+ user = userDAO.find(4L);
+ assertEquals(1, user.getRelationships().size());
+ assertEquals(2L, user.getRelationships().get(0).getRightEnd().getKey(), 0);
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnySearchTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnySearchTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnySearchTest.java
deleted file mode 100644
index b038222..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnySearchTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import org.apache.syncope.common.lib.SyncopeConstants;
-import org.apache.syncope.common.lib.types.AnyTypeKind;
-import org.apache.syncope.common.lib.types.Entitlement;
-import org.apache.syncope.core.persistence.api.dao.GroupDAO;
-import org.apache.syncope.core.persistence.api.dao.RealmDAO;
-import org.apache.syncope.core.persistence.api.dao.RoleDAO;
-import org.apache.syncope.core.persistence.api.dao.AnySearchDAO;
-import org.apache.syncope.core.persistence.api.dao.search.AttributeCond;
-import org.apache.syncope.core.persistence.api.dao.search.RoleCond;
-import org.apache.syncope.core.persistence.api.dao.search.SearchCond;
-import org.apache.syncope.core.persistence.api.entity.user.DynRoleMembership;
-import org.apache.syncope.core.persistence.api.entity.Role;
-import org.apache.syncope.core.persistence.api.entity.group.Group;
-import org.apache.syncope.core.persistence.api.entity.user.User;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class AnySearchTest extends AbstractTest {
-
- @Autowired
- private GroupDAO groupDAO;
-
- @Autowired
- private AnySearchDAO searchDAO;
-
- @Autowired
- private RealmDAO realmDAO;
-
- @Autowired
- private RoleDAO roleDAO;
-
- @Test
- public void issueSYNCOPE95() {
- Set<Group> groups = new HashSet<>(groupDAO.findAll(SyncopeConstants.FULL_ADMIN_REALMS, 1, 100));
- for (Group group : groups) {
- groupDAO.delete(group.getKey());
- }
- groupDAO.flush();
-
- AttributeCond coolLeafCond = new AttributeCond(AttributeCond.Type.EQ);
- coolLeafCond.setSchema("cool");
- coolLeafCond.setExpression("true");
-
- SearchCond cond = SearchCond.getLeafCond(coolLeafCond);
- assertTrue(cond.isValid());
-
- List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, cond, AnyTypeKind.USER);
- assertNotNull(users);
- assertEquals(1, users.size());
-
- assertEquals(4L, users.get(0).getKey(), 0);
- }
-
- @Test
- public void searchByDynMembership() {
- // 1. create role with dynamic membership
- Role role = entityFactory.newEntity(Role.class);
- role.setName("new");
- role.addRealm(realmDAO.getRoot());
- role.addRealm(realmDAO.find("/even/two"));
- role.getEntitlements().add(Entitlement.LOG_LIST);
- role.getEntitlements().add(Entitlement.LOG_SET_LEVEL);
-
- DynRoleMembership dynMembership = entityFactory.newEntity(DynRoleMembership.class);
- dynMembership.setFIQLCond("cool==true");
- dynMembership.setRole(role);
-
- role.setDynMembership(dynMembership);
-
- role = roleDAO.save(role);
- assertNotNull(role);
-
- roleDAO.flush();
-
- // 2. search user by this dynamic role
- RoleCond roleCond = new RoleCond();
- roleCond.setRoleKey(role.getKey());
-
- List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS,
- SearchCond.getLeafCond(roleCond), AnyTypeKind.USER);
- assertNotNull(users);
- assertEquals(1, users.size());
- assertEquals(4L, users.get(0).getKey(), 0);
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeClassTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeClassTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeClassTest.java
deleted file mode 100644
index 4b5f2f5..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeClassTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import static org.junit.Assert.assertTrue;
-
-import org.apache.syncope.core.persistence.api.dao.AnyTypeClassDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
-import org.apache.syncope.core.persistence.api.entity.AnyTypeClass;
-import org.apache.syncope.core.persistence.api.entity.PlainSchema;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class AnyTypeClassTest extends AbstractTest {
-
- @Autowired
- private PlainSchemaDAO plainSchemaDAO;
-
- @Autowired
- private AnyTypeClassDAO anyTypeClassDAO;
-
- @Test
- public void delete() {
- AnyTypeClass minimalUser = anyTypeClassDAO.find("minimal user");
- assertNotNull(minimalUser);
-
- PlainSchema surname = plainSchemaDAO.find("surname");
- assertNotNull(surname);
- assertTrue(minimalUser.getPlainSchemas().contains(surname));
- int before = minimalUser.getPlainSchemas().size();
-
- plainSchemaDAO.delete("surname");
-
- anyTypeClassDAO.flush();
-
- minimalUser = anyTypeClassDAO.find("minimal user");
- assertNotNull(minimalUser);
- assertEquals(before, minimalUser.getPlainSchemas().size() + 1);
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeTest.java
deleted file mode 100644
index 60ff041..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/AnyTypeTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import org.apache.syncope.core.persistence.api.dao.AnyTypeClassDAO;
-import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO;
-import org.apache.syncope.core.persistence.api.entity.AnyType;
-import org.apache.syncope.core.persistence.api.entity.AnyTypeClass;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class AnyTypeTest extends AbstractTest {
-
- @Autowired
- private AnyTypeDAO anyTypeDAO;
-
- @Autowired
- private AnyTypeClassDAO anyTypeClassDAO;
-
- @Test
- public void delete() {
- AnyType userType = anyTypeDAO.findUser();
- assertNotNull(userType);
-
- AnyTypeClass other = anyTypeClassDAO.find("other");
- assertNotNull(other);
- assertTrue(userType.getClasses().contains(other));
- int before = userType.getClasses().size();
-
- anyTypeClassDAO.delete("other");
-
- anyTypeDAO.flush();
-
- userType = anyTypeDAO.findUser();
- assertNotNull(userType);
- assertEquals(before, userType.getClasses().size() + 1);
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/ConnInstanceTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/ConnInstanceTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/ConnInstanceTest.java
deleted file mode 100644
index 34aaef5..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/ConnInstanceTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-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 java.util.List;
-import org.apache.syncope.common.lib.types.ConnectorCapability;
-import org.apache.syncope.core.persistence.api.dao.ConnInstanceDAO;
-import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
-import org.apache.syncope.core.persistence.api.entity.ConnInstance;
-import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class ConnInstanceTest extends AbstractTest {
-
- @Autowired
- private ExternalResourceDAO resourceDAO;
-
- @Autowired
- private ConnInstanceDAO connInstanceDAO;
-
- @Test
- public void deleteCascade() {
- ConnInstance connInstance = connInstanceDAO.find(103L);
- assertNotNull(connInstance);
-
- List<? extends ExternalResource> resources = connInstance.getResources();
- assertNotNull(resources);
- assertFalse(resources.isEmpty());
-
- connInstanceDAO.delete(connInstance.getKey());
-
- connInstanceDAO.flush();
-
- ConnInstance actual = connInstanceDAO.find(103L);
- assertNull(actual);
-
- for (ExternalResource resource : resources) {
- assertNull(resourceDAO.find(resource.getKey()));
- }
- }
-
- /**
- * Connector change used to miss connector bean registration.
- *
- * http://code.google.com/p/syncope/issues/detail?id=176
- */
- @Test
- public void issue176() {
- ConnInstance connInstance = connInstanceDAO.find(103L);
- assertNotNull(connInstance);
- assertTrue(connInstance.getCapabilities().isEmpty());
-
- List<? extends ExternalResource> resources = connInstance.getResources();
- assertNotNull(resources);
- assertEquals(4, resources.size());
- assertTrue(
- "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(0).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(1).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(2).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(3).getKey()));
-
- connInstance.addCapability(ConnectorCapability.SEARCH);
-
- connInstance = connInstanceDAO.save(connInstance);
- assertNotNull(connInstance);
- assertFalse(connInstance.getCapabilities().isEmpty());
-
- resources = connInstance.getResources();
- assertNotNull(resources);
- assertEquals(4, resources.size());
- assertTrue(
- "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(0).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(1).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(2).getKey())
- || "ws-target-resource-nopropagation".equalsIgnoreCase(resources.get(3).getKey()));
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/DerSchemaTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/DerSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/DerSchemaTest.java
deleted file mode 100644
index 9448886..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/DerSchemaTest.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-import static org.junit.Assert.assertNull;
-
-import org.apache.syncope.core.persistence.api.dao.DerAttrDAO;
-import org.apache.syncope.core.persistence.api.dao.DerSchemaDAO;
-import org.apache.syncope.core.persistence.api.dao.UserDAO;
-import org.apache.syncope.core.persistence.api.entity.DerSchema;
-import org.apache.syncope.core.persistence.api.entity.user.UDerAttr;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class DerSchemaTest extends AbstractTest {
-
- @Autowired
- private UserDAO userDAO;
-
- @Autowired
- private DerSchemaDAO derSchemaDAO;
-
- @Autowired
- private DerAttrDAO derAttrDAO;
-
- @Test
- public void test() {
- DerSchema schema = derSchemaDAO.find("cn");
-
- derSchemaDAO.delete(schema.getKey());
-
- derSchemaDAO.flush();
-
- assertNull(derSchemaDAO.find(schema.getKey()));
- assertNull(derAttrDAO.find(100L, UDerAttr.class));
- assertNull(userDAO.find(3L).getDerAttr(schema.getKey()));
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/GroupTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/GroupTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/GroupTest.java
deleted file mode 100644
index 50b4c56..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/GroupTest.java
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-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 java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import javax.persistence.EntityManager;
-import javax.persistence.TypedQuery;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.collections4.Transformer;
-import org.apache.syncope.common.lib.types.AnyTypeKind;
-import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException;
-import org.apache.syncope.core.persistence.api.dao.AnyObjectDAO;
-import org.apache.syncope.core.persistence.api.dao.AnyTypeClassDAO;
-import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainAttrDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainAttrValueDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
-import org.apache.syncope.core.persistence.api.dao.GroupDAO;
-import org.apache.syncope.core.persistence.api.dao.RealmDAO;
-import org.apache.syncope.core.persistence.api.dao.UserDAO;
-import org.apache.syncope.core.persistence.api.entity.anyobject.ADynGroupMembership;
-import org.apache.syncope.core.persistence.api.entity.anyobject.APlainAttr;
-import org.apache.syncope.core.persistence.api.entity.anyobject.AnyObject;
-import org.apache.syncope.core.persistence.api.entity.group.GPlainAttr;
-import org.apache.syncope.core.persistence.api.entity.group.GPlainAttrValue;
-import org.apache.syncope.core.persistence.api.entity.group.Group;
-import org.apache.syncope.core.persistence.api.entity.user.UDynGroupMembership;
-import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr;
-import org.apache.syncope.core.persistence.api.entity.user.User;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAADynGroupMembership;
-import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDynGroupMembership;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class GroupTest extends AbstractTest {
-
- @Autowired
- private EntityManager entityManager;
-
- @Autowired
- private AnyTypeDAO anyTypeDAO;
-
- @Autowired
- private AnyObjectDAO anyObjectDAO;
-
- @Autowired
- private UserDAO userDAO;
-
- @Autowired
- private GroupDAO groupDAO;
-
- @Autowired
- private RealmDAO realmDAO;
-
- @Autowired
- private PlainSchemaDAO plainSchemaDAO;
-
- @Autowired
- private PlainAttrDAO plainAttrDAO;
-
- @Autowired
- private PlainAttrValueDAO plainAttrValueDAO;
-
- @Autowired
- private AnyTypeClassDAO anyTypeClassDAO;
-
- @Test(expected = InvalidEntityException.class)
- public void saveWithTwoOwners() {
- Group root = groupDAO.find("root");
- assertNotNull("did not find expected group", root);
-
- User user = userDAO.find(1L);
- assertNotNull("did not find expected user", user);
-
- Group group = entityFactory.newEntity(Group.class);
- group.setRealm(realmDAO.getRoot());
- group.setName("error");
- group.setUserOwner(user);
- group.setGroupOwner(root);
-
- groupDAO.save(group);
- }
-
- @Test
- public void findByOwner() {
- Group group = groupDAO.find(6L);
- assertNotNull("did not find expected group", group);
-
- User user = userDAO.find(5L);
- assertNotNull("did not find expected user", user);
-
- assertEquals(user, group.getUserOwner());
-
- List<Group> ownedGroups = groupDAO.findOwnedByUser(user.getKey());
- assertFalse(ownedGroups.isEmpty());
- assertEquals(1, ownedGroups.size());
- assertTrue(ownedGroups.contains(group));
- }
-
- @Test
- public void delete() {
- groupDAO.delete(2L);
-
- groupDAO.flush();
-
- assertNull(groupDAO.find(2L));
- assertEquals(userDAO.findAllGroups(userDAO.find(2L)).size(), 2);
- assertNull(plainAttrDAO.find(700L, GPlainAttr.class));
- assertNull(plainAttrValueDAO.find(41L, GPlainAttrValue.class));
- assertNotNull(plainSchemaDAO.find("icon"));
- }
-
- /**
- * Static copy of {@link org.apache.syncope.core.persistence.jpa.dao.JPAUserDAO} method with same signature:
- * required for avoiding creating of a new transaction - good for general use case but bad for the way how
- * this test class is architected.
- */
- private Collection<Group> findDynGroupMemberships(final User user) {
- TypedQuery<Group> query = entityManager.createQuery(
- "SELECT e.group FROM " + JPAUDynGroupMembership.class.getSimpleName()
- + " e WHERE :user MEMBER OF e.users", Group.class);
- query.setParameter("user", user);
-
- return query.getResultList();
- }
-
- @Test
- public void udynMembership() {
- // 0. create user matching the condition below
- User user = entityFactory.newEntity(User.class);
- user.setUsername("username");
- user.setRealm(realmDAO.find("/even/two"));
- user.add(anyTypeClassDAO.find("other"));
-
- UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class);
- attr.setOwner(user);
- attr.setSchema(plainSchemaDAO.find("cool"));
- attr.add("true", anyUtilsFactory.getInstance(AnyTypeKind.USER));
- user.add(attr);
-
- user = userDAO.save(user);
- Long newUserKey = user.getKey();
- assertNotNull(newUserKey);
-
- // 1. create group with dynamic membership
- Group group = entityFactory.newEntity(Group.class);
- group.setRealm(realmDAO.getRoot());
- group.setName("new");
-
- UDynGroupMembership dynMembership = entityFactory.newEntity(UDynGroupMembership.class);
- dynMembership.setFIQLCond("cool==true");
- dynMembership.setGroup(group);
-
- group.setUDynMembership(dynMembership);
-
- Group actual = groupDAO.save(group);
- assertNotNull(actual);
-
- groupDAO.flush();
-
- // 2. verify that dynamic membership is there
- actual = groupDAO.find(actual.getKey());
- assertNotNull(actual);
- assertNotNull(actual.getUDynMembership());
- assertNotNull(actual.getUDynMembership().getKey());
- assertEquals(actual, actual.getUDynMembership().getGroup());
-
- // 3. verify that expected users have the created group dynamically assigned
- assertEquals(2, actual.getUDynMembership().getMembers().size());
- assertEquals(new HashSet<>(Arrays.asList(4L, newUserKey)),
- CollectionUtils.collect(actual.getUDynMembership().getMembers(), new Transformer<User, Long>() {
-
- @Override
- public Long transform(final User input) {
- return input.getKey();
- }
- }, new HashSet<Long>()));
-
- user = userDAO.find(4L);
- assertNotNull(user);
- Collection<Group> dynGroupMemberships = findDynGroupMemberships(user);
- assertEquals(1, dynGroupMemberships.size());
- assertTrue(dynGroupMemberships.contains(actual.getUDynMembership().getGroup()));
-
- // 4. delete the new user and verify that dynamic membership was updated
- userDAO.delete(newUserKey);
-
- userDAO.flush();
-
- actual = groupDAO.find(actual.getKey());
- assertEquals(1, actual.getUDynMembership().getMembers().size());
- assertEquals(4L, actual.getUDynMembership().getMembers().get(0).getKey(), 0);
-
- // 5. delete group and verify that dynamic membership was also removed
- Long dynMembershipKey = actual.getUDynMembership().getKey();
-
- groupDAO.delete(actual);
-
- groupDAO.flush();
-
- assertNull(entityManager.find(JPAUDynGroupMembership.class, dynMembershipKey));
-
- dynGroupMemberships = findDynGroupMemberships(user);
- assertTrue(dynGroupMemberships.isEmpty());
- }
-
- /**
- * Static copy of {@link org.apache.syncope.core.persistence.jpa.dao.JPAAnyObjectDAO} method with same signature:
- * required for avoiding creating of a new transaction - good for general use case but bad for the way how
- * this test class is architected.
- */
- private List<Group> findDynGroupMemberships(final AnyObject anyObject) {
- TypedQuery<Group> query = entityManager.createQuery(
- "SELECT e.group FROM " + JPAADynGroupMembership.class.getSimpleName()
- + " e WHERE :anyObject MEMBER OF e.anyObjects", Group.class);
- query.setParameter("anyObject", anyObject);
-
- return query.getResultList();
- }
-
- @Test
- public void adynMembership() {
- // 0. create any object matching the condition below
- AnyObject anyObject = entityFactory.newEntity(AnyObject.class);
- anyObject.setType(anyTypeDAO.find("PRINTER"));
- anyObject.setRealm(realmDAO.find("/even/two"));
-
- APlainAttr attr = entityFactory.newEntity(APlainAttr.class);
- attr.setOwner(anyObject);
- attr.setSchema(plainSchemaDAO.find("model"));
- attr.add("Canon MFC8030", anyUtilsFactory.getInstance(AnyTypeKind.ANY_OBJECT));
- anyObject.add(attr);
-
- anyObject = anyObjectDAO.save(anyObject);
- Long newAnyObjectKey = anyObject.getKey();
- assertNotNull(newAnyObjectKey);
-
- // 1. create group with dynamic membership
- Group group = entityFactory.newEntity(Group.class);
- group.setRealm(realmDAO.getRoot());
- group.setName("new");
-
- ADynGroupMembership dynMembership = entityFactory.newEntity(ADynGroupMembership.class);
- dynMembership.setFIQLCond("model==Canon MFC8030");
- dynMembership.setGroup(group);
-
- group.setADynMembership(dynMembership);
-
- Group actual = groupDAO.save(group);
- assertNotNull(actual);
-
- groupDAO.flush();
-
- // 2. verify that dynamic membership is there
- actual = groupDAO.find(actual.getKey());
- assertNotNull(actual);
- assertNotNull(actual.getADynMembership());
- assertNotNull(actual.getADynMembership().getKey());
- assertEquals(actual, actual.getADynMembership().getGroup());
-
- // 3. verify that expected any objects have the created group dynamically assigned
- assertEquals(2, actual.getADynMembership().getMembers().size());
- assertEquals(new HashSet<>(Arrays.asList(1L, newAnyObjectKey)),
- CollectionUtils.collect(actual.getADynMembership().getMembers(), new Transformer<AnyObject, Long>() {
-
- @Override
- public Long transform(final AnyObject input) {
- return input.getKey();
- }
- }, new HashSet<Long>()));
-
- anyObject = anyObjectDAO.find(1L);
- assertNotNull(anyObject);
- Collection<Group> dynGroupMemberships = findDynGroupMemberships(anyObject);
- assertEquals(1, dynGroupMemberships.size());
- assertTrue(dynGroupMemberships.contains(actual.getADynMembership().getGroup()));
-
- // 4. delete the new any object and verify that dynamic membership was updated
- anyObjectDAO.delete(newAnyObjectKey);
-
- anyObjectDAO.flush();
-
- actual = groupDAO.find(actual.getKey());
- assertEquals(1, actual.getADynMembership().getMembers().size());
- assertEquals(1L, actual.getADynMembership().getMembers().get(0).getKey(), 0);
-
- // 5. delete group and verify that dynamic membership was also removed
- Long dynMembershipKey = actual.getADynMembership().getKey();
-
- groupDAO.delete(actual);
-
- groupDAO.flush();
-
- assertNull(entityManager.find(JPAADynGroupMembership.class, dynMembershipKey));
-
- dynGroupMemberships = findDynGroupMemberships(anyObject);
- assertTrue(dynGroupMemberships.isEmpty());
- }
-
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainAttrTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainAttrTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainAttrTest.java
deleted file mode 100644
index ae4220c..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainAttrTest.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-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 org.apache.syncope.common.lib.SyncopeConstants;
-import org.apache.syncope.common.lib.types.AnyTypeKind;
-import org.apache.syncope.common.lib.types.AttrSchemaType;
-import org.apache.syncope.common.lib.types.CipherAlgorithm;
-import org.apache.syncope.core.persistence.api.dao.AnyTypeClassDAO;
-import org.apache.syncope.core.persistence.api.dao.DerAttrDAO;
-import org.apache.syncope.core.persistence.api.dao.DerSchemaDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainAttrDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainAttrValueDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
-import org.apache.syncope.core.persistence.api.dao.UserDAO;
-import org.apache.syncope.core.persistence.api.entity.AnyTypeClass;
-import org.apache.syncope.core.persistence.api.entity.DerSchema;
-import org.apache.syncope.core.persistence.api.entity.PlainSchema;
-import org.apache.syncope.core.persistence.api.entity.user.UDerAttr;
-import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr;
-import org.apache.syncope.core.persistence.api.entity.user.UPlainAttrValue;
-import org.apache.syncope.core.persistence.api.entity.user.User;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class PlainAttrTest extends AbstractTest {
-
- @Autowired
- private PlainAttrDAO plainAttrDAO;
-
- @Autowired
- private DerAttrDAO derAttrDAO;
-
- @Autowired
- private PlainAttrValueDAO plainAttrValueDAO;
-
- @Autowired
- private PlainSchemaDAO plainSchemaDAO;
-
- @Autowired
- private DerSchemaDAO derSchemaDAO;
-
- @Autowired
- private UserDAO userDAO;
-
- @Autowired
- private AnyTypeClassDAO anyTypeClassDAO;
-
- @Test
- public void deleteAttribute() {
- plainAttrDAO.delete(117L, UPlainAttr.class);
-
- plainAttrDAO.flush();
-
- assertNull(plainAttrDAO.find(117L, UPlainAttr.class));
- assertNull(plainAttrValueDAO.find(28L, UPlainAttrValue.class));
- }
-
- @Test
- public void deleteAttributeValue() {
- UPlainAttrValue value = plainAttrValueDAO.find(14L, UPlainAttrValue.class);
- int attributeValueNumber = value.getAttr().getValues().size();
-
- plainAttrValueDAO.delete(value.getKey(), UPlainAttrValue.class);
-
- plainAttrValueDAO.flush();
-
- assertNull(plainAttrValueDAO.find(value.getKey(), UPlainAttrValue.class));
-
- UPlainAttr attribute = plainAttrDAO.find(104L, UPlainAttr.class);
- assertEquals(attribute.getValues().size(), attributeValueNumber - 1);
- }
-
- @Test
- public void checkForEnumType() {
- User user = userDAO.find(1L);
- user.setPassword("password123", CipherAlgorithm.SHA);
- assertNotNull(user);
-
- AnyTypeClass other = anyTypeClassDAO.find("other");
-
- PlainSchema color = entityFactory.newEntity(PlainSchema.class);
- color.setType(AttrSchemaType.Enum);
- color.setKey("color");
- color.setEnumerationValues("red" + SyncopeConstants.ENUM_VALUES_SEPARATOR + "yellow");
-
- color = plainSchemaDAO.save(color);
-
- other.add(color);
- color.setAnyTypeClass(other);
-
- plainSchemaDAO.flush();
-
- color = plainSchemaDAO.find("color");
- assertNotNull("expected save to work", color);
- assertEquals(other, color.getAnyTypeClass());
-
- UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class);
- attr.setOwner(user);
- attr.setSchema(color);
- attr.add("yellow", anyUtilsFactory.getInstance(AnyTypeKind.USER));
- user.add(attr);
-
- userDAO.save(user);
- userDAO.flush();
-
- user = userDAO.find(1L);
- assertNotNull(user);
- assertNotNull(user.getPlainAttr(color.getKey()));
- assertNotNull(user.getPlainAttr(color.getKey()).getValues());
- assertEquals(user.getPlainAttr(color.getKey()).getValues().size(), 1);
- }
-
- @Test
- public void derAttrFromSpecialAttrs() {
- AnyTypeClass other = anyTypeClassDAO.find("other");
-
- DerSchema sderived = entityFactory.newEntity(DerSchema.class);
- sderived.setKey("sderived");
- sderived.setExpression("username + ' - ' + creationDate + '[' + failedLogins + ']'");
-
- sderived = derSchemaDAO.save(sderived);
-
- derSchemaDAO.flush();
-
- other.add(sderived);
- sderived.setAnyTypeClass(other);
-
- derSchemaDAO.flush();
-
- sderived = derSchemaDAO.find("sderived");
- assertNotNull("expected save to work", sderived);
- assertEquals(other, sderived.getAnyTypeClass());
-
- User owner = userDAO.find(3L);
- assertNotNull("did not get expected user", owner);
-
- UDerAttr derAttr = entityFactory.newEntity(UDerAttr.class);
- derAttr.setOwner(owner);
- derAttr.setSchema(sderived);
-
- derAttr = derAttrDAO.save(derAttr);
- derAttrDAO.flush();
-
- derAttr = derAttrDAO.find(derAttr.getKey(), UDerAttr.class);
- assertNotNull("expected save to work", derAttr);
-
- String value = derAttr.getValue(owner.getPlainAttrs());
- assertNotNull(value);
- assertFalse(value.isEmpty());
- assertTrue(value.startsWith("vivaldi - 2010-10-20"));
- assertTrue(value.endsWith("[0]"));
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainSchemaTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainSchemaTest.java
deleted file mode 100644
index 7d363c2..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/PlainSchemaTest.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-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 java.util.HashSet;
-import java.util.Set;
-import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO;
-import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainAttrDAO;
-import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
-import org.apache.syncope.core.persistence.api.dao.UserDAO;
-import org.apache.syncope.core.persistence.api.entity.PlainSchema;
-import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource;
-import org.apache.syncope.core.persistence.api.entity.resource.MappingItem;
-import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class PlainSchemaTest extends AbstractTest {
-
- @Autowired
- private AnyTypeDAO anyTypeDAO;
-
- @Autowired
- private UserDAO userDAO;
-
- @Autowired
- private PlainSchemaDAO plainSchemaDAO;
-
- @Autowired
- private PlainAttrDAO plainAttrDAO;
-
- @Autowired
- private ExternalResourceDAO resourceDAO;
-
- @Test
- public void deleteFullname() {
- // fullname is mapped as ConnObjectKey for ws-target-resource-2, need to swap it otherwise validation errors
- // will be raised
- for (MappingItem item : resourceDAO.find("ws-target-resource-2").
- getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
-
- if ("fullname".equals(item.getIntAttrName())) {
- item.setConnObjectKey(false);
- } else if ("surname".equals(item.getIntAttrName())) {
- item.setConnObjectKey(true);
- }
- }
-
- // search for user schema fullname
- PlainSchema schema = plainSchemaDAO.find("fullname");
- assertNotNull(schema);
-
- // check for associated mappings
- Set<MappingItem> mapItems = new HashSet<>();
- for (ExternalResource resource : resourceDAO.findAll()) {
- if (resource.getProvision(anyTypeDAO.findUser()) != null
- && resource.getProvision(anyTypeDAO.findUser()).getMapping() != null) {
-
- for (MappingItem mapItem : resource.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
- if (schema.getKey().equals(mapItem.getIntAttrName())) {
- mapItems.add(mapItem);
- }
- }
- }
- }
- assertFalse(mapItems.isEmpty());
-
- // delete user schema fullname
- plainSchemaDAO.delete("fullname");
-
- plainSchemaDAO.flush();
-
- // check for schema deletion
- schema = plainSchemaDAO.find("fullname");
- assertNull(schema);
-
- plainSchemaDAO.clear();
-
- // check for mappings deletion
- mapItems = new HashSet<>();
- for (ExternalResource resource : resourceDAO.findAll()) {
- if (resource.getProvision(anyTypeDAO.findUser()) != null
- && resource.getProvision(anyTypeDAO.findUser()).getMapping() != null) {
-
- for (MappingItem mapItem : resource.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
- if ("fullname".equals(mapItem.getIntAttrName())) {
- mapItems.add(mapItem);
- }
- }
- }
- }
- assertTrue(mapItems.isEmpty());
-
- assertNull(plainAttrDAO.find(100L, UPlainAttr.class));
- assertNull(plainAttrDAO.find(300L, UPlainAttr.class));
- assertNull(userDAO.find(1L).getPlainAttr("fullname"));
- assertNull(userDAO.find(3L).getPlainAttr("fullname"));
- }
-
- @Test
- public void deleteSurname() {
- // search for user schema fullname
- PlainSchema schema = plainSchemaDAO.find("surname");
- assertNotNull(schema);
-
- // check for associated mappings
- Set<MappingItem> mappings = new HashSet<>();
- for (ExternalResource resource : resourceDAO.findAll()) {
- if (resource.getProvision(anyTypeDAO.findUser()) != null
- && resource.getProvision(anyTypeDAO.findUser()).getMapping() != null) {
-
- for (MappingItem mapItem : resource.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
- if (schema.getKey().equals(mapItem.getIntAttrName())) {
- mappings.add(mapItem);
- }
- }
- }
- }
- assertFalse(mappings.isEmpty());
-
- // delete user schema fullname
- plainSchemaDAO.delete("surname");
-
- plainSchemaDAO.flush();
-
- // check for schema deletion
- schema = plainSchemaDAO.find("surname");
- assertNull(schema);
- }
-
- @Test
- public void deleteALong() {
- assertEquals(6, resourceDAO.find("resource-db-sync").
- getProvision(anyTypeDAO.findUser()).getMapping().getItems().size());
-
- plainSchemaDAO.delete("aLong");
- assertNull(plainSchemaDAO.find("aLong"));
-
- plainSchemaDAO.flush();
-
- assertEquals(5, resourceDAO.find("resource-db-sync").
- getProvision(anyTypeDAO.findUser()).getMapping().getItems().size());
- }
-}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/RealmTest.java
----------------------------------------------------------------------
diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/RealmTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/RealmTest.java
deleted file mode 100644
index e652e62..0000000
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/relationship/RealmTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * 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.core.persistence.jpa.relationship;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import org.apache.syncope.core.persistence.api.dao.RealmDAO;
-import org.apache.syncope.core.persistence.api.dao.RoleDAO;
-import org.apache.syncope.core.persistence.api.entity.Realm;
-import org.apache.syncope.core.persistence.api.entity.Role;
-import org.apache.syncope.core.persistence.jpa.AbstractTest;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class RealmTest extends AbstractTest {
-
- @Autowired
- private RealmDAO realmDAO;
-
- @Autowired
- private RoleDAO roleDAO;
-
- @Test
- public void test() {
- Realm realm = realmDAO.find("/odd");
- assertNotNull(realm);
-
- Role role = roleDAO.find(1L);
- assertTrue(role.getRealms().contains(realm));
-
- int beforeSize = role.getRealms().size();
-
- realmDAO.delete(realm);
-
- realmDAO.flush();
-
- role = roleDAO.find(1L);
- assertEquals(beforeSize - 1, role.getRealms().size());
- }
-}