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("[email protected]"); + + 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()); - } -}
