http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ConnInstanceTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ConnInstanceTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ConnInstanceTest.java new file mode 100644 index 0000000..70665ed --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ConnInstanceTest.java @@ -0,0 +1,145 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.apache.syncope.common.lib.types.ConnConfPropSchema; +import org.apache.syncope.common.lib.types.ConnConfProperty; +import org.apache.syncope.core.persistence.api.dao.ConnInstanceDAO; +import org.apache.syncope.core.persistence.api.entity.ConnInstance; +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 ConnInstanceDAO connInstanceDAO; + + @Test + public void findAll() { + List<ConnInstance> connectors = connInstanceDAO.findAll(); + assertNotNull(connectors); + assertFalse(connectors.isEmpty()); + } + + @Test + public void findById() { + ConnInstance connectorInstance = connInstanceDAO.find(100L); + + assertNotNull("findById did not work", connectorInstance); + + assertEquals("invalid connector name", + "net.tirasa.connid.bundles.soap.WebServiceConnector", connectorInstance.getConnectorName()); + + assertEquals("invalid bundle name", "net.tirasa.connid.bundles.soap", connectorInstance.getBundleName()); + } + + @Test + public void save() throws ClassNotFoundException { + ConnInstance connInstance = entityFactory.newEntity(ConnInstance.class); + + connInstance.setLocation(new File(System.getProperty("java.io.tmpdir")).toURI().toString()); + + // set connector version + connInstance.setVersion("1.0"); + + // set connector name + connInstance.setConnectorName("WebService"); + + // set bundle name + connInstance.setBundleName("org.apache.syncope.core.persistence.test.util"); + + connInstance.setDisplayName("New"); + + connInstance.setConnRequestTimeout(60); + + // set the connector configuration using PropertyTO + Set<ConnConfProperty> conf = new HashSet<ConnConfProperty>(); + + ConnConfPropSchema endpointSchema = new ConnConfPropSchema(); + endpointSchema.setName("endpoint"); + endpointSchema.setType(String.class.getName()); + endpointSchema.setRequired(true); + ConnConfProperty endpoint = new ConnConfProperty(); + endpoint.setSchema(endpointSchema); + endpoint.getValues().add("http://host.domain";); + + ConnConfPropSchema servicenameSchema = new ConnConfPropSchema(); + servicenameSchema.setName("servicename"); + servicenameSchema.setType(String.class.getName()); + servicenameSchema.setRequired(true); + ConnConfProperty servicename = new ConnConfProperty(); + servicename.setSchema(servicenameSchema); + endpoint.getValues().add("Provisioning"); + + conf.add(endpoint); + conf.add(servicename); + + // set connector configuration + connInstance.setConfiguration(conf); + assertFalse(connInstance.getConfiguration().isEmpty()); + + // perform save operation + ConnInstance actual = connInstanceDAO.save(connInstance); + + assertNotNull("save did not work", actual.getKey()); + + assertTrue("save did not work", actual.getKey() > 100L); + + assertEquals("save did not work for \"name\" attribute", "WebService", actual.getConnectorName()); + + assertEquals("save did not work for \"bundle name\" attribute", "org.apache.syncope.core.persistence.test.util", + actual.getBundleName()); + + assertEquals("save did not work for \"majorVersion\" attribute", "1.0", connInstance.getVersion()); + + assertEquals("New", actual.getDisplayName()); + + assertEquals(60, actual.getConnRequestTimeout(), 0); + + conf = connInstance.getConfiguration(); + assertFalse(conf.isEmpty()); + + assertNotNull("configuration retrieving failed", conf); + assertTrue(conf.size() == 2); + } + + @Test + public void delete() { + ConnInstance connectorInstance = connInstanceDAO.find(100L); + assertNotNull("find to delete did not work", connectorInstance); + + connInstanceDAO.delete(connectorInstance.getKey()); + + ConnInstance actual = connInstanceDAO.find(100L); + assertNull("delete did not work", actual); + } +}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerAttrTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerAttrTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerAttrTest.java new file mode 100644 index 0000000..cd336ae --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerAttrTest.java @@ -0,0 +1,220 @@ +/* + * 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.inner; + +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.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.GroupDAO; +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.group.GDerAttr; +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.UDerAttr; +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 DerAttrTest extends AbstractTest { + + @Autowired + private DerAttrDAO derAttrDAO; + + @Autowired + private UserDAO userDAO; + + @Autowired + private GroupDAO groupDAO; + + @Autowired + private DerSchemaDAO derSchemaDAO; + + @Autowired + private AnyTypeClassDAO anyTypeClassDAO; + + @Test + public void findAll() { + List<UDerAttr> list = derAttrDAO.findAll(UDerAttr.class); + assertEquals("did not get expected number of derived attributes ", 2, list.size()); + } + + @Test + public void findById() { + UDerAttr attribute = derAttrDAO.find(100L, UDerAttr.class); + assertNotNull("did not find expected attribute schema", attribute); + } + + @Test + public void saveUDerAttribute() { + DerSchema cnSchema = derSchemaDAO.find("cn"); + assertNotNull(cnSchema); + + User owner = userDAO.find(3L); + assertNotNull("did not get expected user", owner); + + UDerAttr derAttr = entityFactory.newEntity(UDerAttr.class); + derAttr.setOwner(owner); + derAttr.setSchema(cnSchema); + + derAttr = derAttrDAO.save(derAttr); + + UDerAttr actual = derAttrDAO.find(derAttr.getKey(), UDerAttr.class); + assertNotNull("expected save to work", actual); + assertEquals(derAttr, actual); + + UPlainAttrValue firstname = owner.getPlainAttr("firstname").getValues().iterator().next(); + UPlainAttrValue surname = owner.getPlainAttr("surname").getValues().iterator().next(); + + assertEquals(surname.getValue() + ", " + firstname.getValue(), derAttr.getValue(owner.getPlainAttrs())); + } + + @Test + public void saveGDerAttribute() { + DerSchema schema = derSchemaDAO.find("rderiveddata"); + assertNotNull(schema); + + Group owner = groupDAO.find(1L); + assertNotNull("did not get expected user", owner); + + GDerAttr derAttr = entityFactory.newEntity(GDerAttr.class); + derAttr.setOwner(owner); + derAttr.setSchema(schema); + + derAttr = derAttrDAO.save(derAttr); + + GDerAttr actual = derAttrDAO.find(derAttr.getKey(), GDerAttr.class); + assertNotNull("expected save to work", actual); + assertEquals(derAttr, actual); + + GPlainAttrValue sx = owner.getPlainAttr("rderived_sx").getValues().iterator().next(); + GPlainAttrValue dx = owner.getPlainAttr("rderived_dx").getValues().iterator().next(); + + assertEquals(sx.getValue() + "-" + dx.getValue(), derAttr.getValue(owner.getPlainAttrs())); + } + + @Test + public void delete() { + UDerAttr attribute = derAttrDAO.find(100L, UDerAttr.class); + String schemaName = attribute.getSchema().getKey(); + + derAttrDAO.delete(attribute.getKey(), UDerAttr.class); + + UDerAttr actual = derAttrDAO.find(100L, UDerAttr.class); + assertNull("delete did not work", actual); + + DerSchema attributeSchema = derSchemaDAO.find(schemaName); + assertNotNull("user derived attribute schema deleted when deleting values", attributeSchema); + } + + @Test + public void issueSYNCOPE134User() { + AnyTypeClass other = anyTypeClassDAO.find("other"); + + DerSchema sderived = entityFactory.newEntity(DerSchema.class); + sderived.setKey("sderived"); + sderived.setExpression("status + ' - ' + 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); + owner.add(other); + + 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("active - vivaldi - 2010-10-20")); + assertTrue(value.endsWith("[0]")); + } + + @Test + public void issueSYNCOPE134Group() { + AnyTypeClass genericMembership = anyTypeClassDAO.find("generic membership"); + + DerSchema sderived = entityFactory.newEntity(DerSchema.class); + sderived.setKey("sderived"); + sderived.setExpression("name"); + + sderived = derSchemaDAO.save(sderived); + + derSchemaDAO.flush(); + + genericMembership.add(sderived); + sderived.setAnyTypeClass(genericMembership); + + derSchemaDAO.flush(); + + sderived = derSchemaDAO.find("sderived"); + assertNotNull("expected save to work", sderived); + assertEquals(genericMembership, sderived.getAnyTypeClass()); + + Group owner = groupDAO.find(7L); + assertNotNull("did not get expected group", owner); + owner.add(genericMembership); + + GDerAttr derAttr = entityFactory.newEntity(GDerAttr.class); + derAttr.setOwner(owner); + derAttr.setSchema(sderived); + + derAttr = derAttrDAO.save(derAttr); + derAttrDAO.flush(); + + derAttr = derAttrDAO.find(derAttr.getKey(), GDerAttr.class); + assertNotNull("expected save to work", derAttr); + + String value = derAttr.getValue(owner.getPlainAttrs()); + assertNotNull(value); + assertFalse(value.isEmpty()); + assertTrue(value.startsWith("managingDirector")); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerSchemaTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerSchemaTest.java new file mode 100644 index 0000000..c62ab6e --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/DerSchemaTest.java @@ -0,0 +1,100 @@ +/* + * 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.inner; + +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 static org.junit.Assert.fail; + +import java.util.List; +import org.apache.syncope.common.lib.types.EntityViolationType; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +import org.apache.syncope.core.persistence.api.dao.DerSchemaDAO; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +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 DerSchemaDAO derSchemaDAO; + + @Test + public void findAll() { + List<DerSchema> list = derSchemaDAO.findAll(); + assertEquals(9, list.size()); + } + + @Test + public void findByName() { + DerSchema attributeSchema = derSchemaDAO.find("cn"); + assertNotNull("did not find expected derived attribute schema", attributeSchema); + } + + @Test + public void save() { + DerSchema derivedAttributeSchema = entityFactory.newEntity(DerSchema.class); + derivedAttributeSchema.setKey("cn2"); + derivedAttributeSchema.setExpression("firstname surname"); + + derSchemaDAO.save(derivedAttributeSchema); + + DerSchema actual = derSchemaDAO.find("cn2"); + assertNotNull("expected save to work", actual); + assertEquals(derivedAttributeSchema, actual); + } + + @Test + public void delete() { + DerSchema cn = derSchemaDAO.find("cn"); + assertNotNull(cn); + + derSchemaDAO.delete(cn.getKey()); + + DerSchema actual = derSchemaDAO.find("cn"); + assertNull("delete did not work", actual); + + // ------------- // + DerSchema rderiveddata = derSchemaDAO.find("rderiveddata"); + assertNotNull(rderiveddata); + + derSchemaDAO.delete(rderiveddata.getKey()); + + actual = derSchemaDAO.find("rderiveddata"); + assertNull("delete did not work", actual); + } + + @Test + public void issueSYNCOPE418() { + DerSchema schema = entityFactory.newEntity(DerSchema.class); + schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); + + try { + derSchemaDAO.save(schema); + fail(); + } catch (InvalidEntityException e) { + assertTrue(e.hasViolation(EntityViolationType.InvalidName)); + } + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/GroupTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/GroupTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/GroupTest.java new file mode 100644 index 0000000..c6a31ef --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/GroupTest.java @@ -0,0 +1,76 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.List; +import org.apache.syncope.common.lib.SyncopeConstants; +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.entity.group.Group; +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 GroupTest extends AbstractTest { + + @Autowired + private GroupDAO groupDAO; + + @Autowired + private RealmDAO realmDAO; + + @Test + public void findAll() { + List<Group> list = groupDAO.findAll(SyncopeConstants.FULL_ADMIN_REALMS, 1, 100); + assertEquals("did not get expected number of groups ", 14, list.size()); + } + + @Test + public void find() { + Group group = groupDAO.find("root"); + assertNotNull("did not find expected group", group); + } + + @Test + public void save() { + Group group = entityFactory.newEntity(Group.class); + group.setName("secondChild"); + group.setRealm(realmDAO.find(SyncopeConstants.ROOT_REALM)); + + group = groupDAO.save(group); + + Group actual = groupDAO.find(group.getKey()); + assertNotNull("expected save to work", actual); + } + + @Test + public void delete() { + Group group = groupDAO.find(4L); + groupDAO.delete(group.getKey()); + + Group actual = groupDAO.find(4L); + assertNull("delete did not work", actual); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/NotificationTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/NotificationTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/NotificationTest.java new file mode 100644 index 0000000..150b924 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/NotificationTest.java @@ -0,0 +1,149 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.List; +import org.apache.syncope.common.lib.types.IntMappingType; +import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO; +import org.apache.syncope.core.persistence.api.dao.NotificationDAO; +import org.apache.syncope.core.persistence.api.entity.AnyAbout; +import org.apache.syncope.core.persistence.api.entity.Notification; +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 NotificationTest extends AbstractTest { + + @Autowired + private AnyTypeDAO anyTypeDAO; + + @Autowired + private NotificationDAO notificationDAO; + + @Test + public void find() { + Notification notification = notificationDAO.find(10L); + assertNotNull(notification); + assertNotNull(notification.getEvents()); + assertFalse(notification.getEvents().isEmpty()); + assertNotNull(notification.getAbout(anyTypeDAO.findUser())); + assertNotNull(notification.getRecipients()); + + } + + @Test + public void findAll() { + List<Notification> notifications = notificationDAO.findAll(); + assertNotNull(notifications); + assertFalse(notifications.isEmpty()); + } + + @Test + public void save() { + Notification notification = entityFactory.newEntity(Notification.class); + notification.getEvents().add("save"); + + AnyAbout about = entityFactory.newEntity(AnyAbout.class); + about.setNotification(notification); + notification.add(about); + about.setAnyType(anyTypeDAO.findUser()); + about.set("fake search condition"); + + notification.setRecipients("fake recipients"); + + notification.setRecipientAttrName("email"); + notification.setRecipientAttrType(IntMappingType.UserPlainSchema); + + notification.setSender("[email protected]"); + notification.setSubject("Test notification"); + notification.setTemplate("test"); + + Notification actual = notificationDAO.save(notification); + assertNotNull(actual); + assertNotNull(actual.getKey()); + } + + @Test + public void delete() { + notificationDAO.delete(10L); + assertNull(notificationDAO.find(10L)); + } + + @Test + public void issueSYNCOPE445() { + Notification notification = entityFactory.newEntity(Notification.class); + notification.getEvents().add("save"); + + AnyAbout about = entityFactory.newEntity(AnyAbout.class); + about.setNotification(notification); + notification.add(about); + about.setAnyType(anyTypeDAO.findUser()); + about.set("fake search condition"); + + notification.setRecipients("fake search condition"); + + notification.setRecipientAttrName("email"); + notification.setRecipientAttrType(IntMappingType.UserPlainSchema); + + notification.getStaticRecipients().add("[email protected]"); + + notification.setSender("[email protected]"); + notification.setSubject("Test notification"); + notification.setTemplate("test"); + + Notification actual = notificationDAO.save(notification); + assertNotNull(actual); + assertNotNull(actual.getKey()); + assertNotNull(actual.getStaticRecipients()); + assertFalse(actual.getStaticRecipients().isEmpty()); + } + + @Test + public void issueSYNCOPE446() { + Notification notification = entityFactory.newEntity(Notification.class); + notification.getEvents().add("[REST]:[GroupLogic]:[]:[create]:[SUCCESS]"); + + AnyAbout about = entityFactory.newEntity(AnyAbout.class); + about.setNotification(notification); + notification.add(about); + about.setAnyType(anyTypeDAO.findUser()); + about.set("fake search condition"); + + notification.setRecipientAttrName("email"); + notification.setRecipientAttrType(IntMappingType.UserPlainSchema); + + notification.getStaticRecipients().add("[email protected]"); + + notification.setSender("[email protected]"); + notification.setSubject("Test notification"); + notification.setTemplate("test"); + + Notification actual = notificationDAO.save(notification); + assertNotNull(actual); + assertNotNull(actual.getKey()); + assertNotNull(actual.getStaticRecipients()); + assertFalse(actual.getStaticRecipients().isEmpty()); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainAttrTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainAttrTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainAttrTest.java new file mode 100644 index 0000000..108e622 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainAttrTest.java @@ -0,0 +1,237 @@ +/* + * 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.inner; + +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 static org.junit.Assert.fail; + +import java.io.UnsupportedEncodingException; +import java.util.Arrays; +import java.util.Random; +import javax.validation.ValidationException; +import org.apache.syncope.common.lib.SyncopeConstants; +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.common.lib.types.EntityViolationType; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +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.user.UPlainAttr; +import org.apache.syncope.core.persistence.api.entity.user.UPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.api.entity.user.User; +import org.apache.syncope.core.persistence.jpa.AbstractTest; +import org.apache.syncope.core.misc.security.Encryptor; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; +import org.junit.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.crypto.codec.Base64; +import org.springframework.transaction.annotation.Transactional; + +@Transactional +public class PlainAttrTest extends AbstractTest { + + @Autowired + private UserDAO userDAO; + + @Autowired + private PlainAttrDAO plainAttrDAO; + + @Autowired + private PlainSchemaDAO plainSchemaDAO; + + @Test + public void findById() { + UPlainAttr attribute = plainAttrDAO.find(100L, UPlainAttr.class); + assertNotNull("did not find expected attribute schema", attribute); + attribute = plainAttrDAO.find(104L, UPlainAttr.class); + assertNotNull("did not find expected attribute schema", attribute); + } + + @Test + public void read() { + UPlainAttr attribute = plainAttrDAO.find(100L, UPlainAttr.class); + assertNotNull(attribute); + assertTrue(attribute.getValues().isEmpty()); + assertNotNull(attribute.getUniqueValue()); + } + + @Test + public void save() throws ClassNotFoundException { + User user = userDAO.find(1L); + + PlainSchema emailSchema = plainSchemaDAO.find("email"); + assertNotNull(emailSchema); + + UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class); + attr.setOwner(user); + attr.setSchema(emailSchema); + + Exception thrown = null; + try { + attr.add("[email protected]", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + attr.add("[email protected]", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + } catch (ValidationException e) { + thrown = e; + } + assertNull("no validation exception expected here ", thrown); + + try { + attr.add("http://www.apache.org";, anyUtilsFactory.getInstance(AnyTypeKind.USER)); + } catch (ValidationException e) { + thrown = e; + } + assertNotNull("validation exception expected here ", thrown); + } + + @Test + public void saveWithEnum() throws ClassNotFoundException { + User user = userDAO.find(1L); + assertNotNull(user); + + PlainSchema gender = plainSchemaDAO.find("gender"); + assertNotNull(gender); + assertNotNull(gender.getType()); + assertNotNull(gender.getEnumerationValues()); + + UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); + attribute.setOwner(user); + attribute.setSchema(gender); + user.add(attribute); + + Exception thrown = null; + + try { + attribute.add("A", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + } catch (ValidationException e) { + thrown = e; + } + assertNotNull("validation exception expected here ", thrown); + + attribute.add("M", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + + InvalidEntityException iee = null; + try { + userDAO.save(user); + } catch (InvalidEntityException e) { + iee = e; + } + assertNull(iee); + } + + @Test + public void validateAndSave() { + User user = userDAO.find(1L); + + PlainSchema emailSchema = plainSchemaDAO.find("email"); + assertNotNull(emailSchema); + + PlainSchema fullnameSchema = plainSchemaDAO.find("fullname"); + assertNotNull(fullnameSchema); + + UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class); + attr.setOwner(user); + attr.setSchema(emailSchema); + + UPlainAttrUniqueValue uauv = entityFactory.newEntity(UPlainAttrUniqueValue.class); + uauv.setAttr(attr); + uauv.setSchema(fullnameSchema); + uauv.setStringValue("a value"); + + attr.setUniqueValue(uauv); + + user.add(attr); + + InvalidEntityException iee = null; + try { + userDAO.save(user); + fail(); + } catch (InvalidEntityException e) { + iee = e; + } + assertNotNull(iee); + // for attribute + assertTrue(iee.hasViolation(EntityViolationType.InvalidValueList)); + // for uauv + assertTrue(iee.hasViolation(EntityViolationType.InvalidPlainSchema)); + } + + @Test + public void saveWithEncrypted() throws Exception { + User user = userDAO.find(1L); + + PlainSchema obscureSchema = plainSchemaDAO.find("obscure"); + assertNotNull(obscureSchema); + assertNotNull(obscureSchema.getSecretKey()); + assertNotNull(obscureSchema.getCipherAlgorithm()); + + UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class); + attr.setOwner(user); + attr.setSchema(obscureSchema); + attr.add("testvalue", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + user.add(attr); + + userDAO.save(user); + + UPlainAttr obscure = user.getPlainAttr("obscure"); + assertNotNull(obscure); + assertEquals(1, obscure.getValues().size()); + assertEquals(Encryptor.getInstance(obscureSchema.getSecretKey()). + encode("testvalue", obscureSchema.getCipherAlgorithm()), obscure.getValues().get(0).getStringValue()); + } + + @Test + public void saveWithBinary() throws UnsupportedEncodingException { + User user = userDAO.find(1L); + + PlainSchema photoSchema = plainSchemaDAO.find("photo"); + assertNotNull(photoSchema); + assertNotNull(photoSchema.getMimeType()); + + byte[] bytes = new byte[20]; + new Random().nextBytes(bytes); + String photoB64Value = new String(Base64.encode(bytes), SyncopeConstants.DEFAULT_CHARSET); + + UPlainAttr attr = entityFactory.newEntity(UPlainAttr.class); + attr.setOwner(user); + attr.setSchema(photoSchema); + attr.add(photoB64Value, anyUtilsFactory.getInstance(AnyTypeKind.USER)); + user.add(attr); + + userDAO.save(user); + + UPlainAttr obscure = user.getPlainAttr("photo"); + assertNotNull(obscure); + assertEquals(1, obscure.getValues().size()); + assertTrue(Arrays.equals(bytes, obscure.getValues().get(0).getBinaryValue())); + } + + @Test + public void delete() { + UPlainAttr attribute = plainAttrDAO.find(104L, UPlainAttr.class); + String attrSchemaName = attribute.getSchema().getKey(); + + plainAttrDAO.delete(attribute.getKey(), UPlainAttr.class); + + PlainSchema schema = plainSchemaDAO.find(attrSchemaName); + assertNotNull("user attribute schema deleted when deleting values", schema); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainSchemaTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainSchemaTest.java new file mode 100644 index 0000000..119ae6d --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PlainSchemaTest.java @@ -0,0 +1,152 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.List; +import org.apache.syncope.common.lib.SyncopeConstants; +import org.apache.syncope.common.lib.types.AttrSchemaType; +import org.apache.syncope.common.lib.types.EntityViolationType; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; +import org.apache.syncope.core.persistence.api.entity.group.GPlainAttr; +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 PlainSchemaDAO plainSchemaDAO; + + @Test + public void findAll() { + List<PlainSchema> schemas = plainSchemaDAO.findAll(); + assertEquals(42, schemas.size()); + } + + @Test + public void findByName() { + PlainSchema schema = plainSchemaDAO.find("fullname"); + assertNotNull("did not find expected attribute schema", schema); + } + + @Test + public void findAttrs() { + PlainSchema schema = plainSchemaDAO.find("icon"); + assertNotNull(schema); + + List<GPlainAttr> attrs = plainSchemaDAO.findAttrs(schema, GPlainAttr.class); + assertNotNull(attrs); + assertFalse(attrs.isEmpty()); + } + + @Test + public void save() { + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); + schema.setKey("secondaryEmail"); + schema.setType(AttrSchemaType.String); + schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator"); + schema.setMandatoryCondition("false"); + schema.setMultivalue(true); + + plainSchemaDAO.save(schema); + + PlainSchema actual = plainSchemaDAO.find("secondaryEmail"); + assertNotNull("expected save to work", actual); + assertEquals(schema, actual); + } + + @Test(expected = InvalidEntityException.class) + public void saveNonValid() { + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); + schema.setKey("secondaryEmail"); + schema.setType(AttrSchemaType.String); + schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator"); + schema.setMandatoryCondition("false"); + schema.setMultivalue(true); + schema.setUniqueConstraint(true); + + plainSchemaDAO.save(schema); + } + + @Test + public void checkForEnumType() { + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); + schema.setType(AttrSchemaType.Enum); + schema.setKey("color"); + + Exception ex = null; + try { + plainSchemaDAO.save(schema); + } catch (Exception e) { + ex = e; + } + assertNotNull(ex); + + schema.setEnumerationValues("red" + SyncopeConstants.ENUM_VALUES_SEPARATOR + "yellow"); + schema.setEnumerationKeys("1" + SyncopeConstants.ENUM_VALUES_SEPARATOR + "2"); + + plainSchemaDAO.save(schema); + + PlainSchema actual = plainSchemaDAO.find(schema.getKey()); + assertNotNull(actual); + assertNotNull(actual.getEnumerationKeys()); + assertFalse(actual.getEnumerationKeys().isEmpty()); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidSchema() { + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); + schema.setKey("username"); + plainSchemaDAO.save(schema); + } + + @Test + public void delete() { + PlainSchema firstname = plainSchemaDAO.find("firstname"); + + plainSchemaDAO.delete(firstname.getKey()); + + PlainSchema actual = plainSchemaDAO.find("firstname"); + assertNull("delete did not work", actual); + } + + @Test + public void issueSYNCOPE418() { + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); + schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); + + try { + plainSchemaDAO.save(schema); + fail(); + } catch (InvalidEntityException e) { + assertTrue(e.hasViolation(EntityViolationType.InvalidName)); + } + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PolicyTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PolicyTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PolicyTest.java new file mode 100644 index 0000000..ed11445 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/PolicyTest.java @@ -0,0 +1,143 @@ +/* + * 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.inner; + +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 java.util.List; +import org.apache.syncope.common.lib.types.PasswordPolicySpec; +import org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.common.lib.types.SyncPolicySpec; +import org.apache.syncope.common.lib.types.SyncPolicySpecItem; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO; +import org.apache.syncope.core.persistence.api.dao.PolicyDAO; +import org.apache.syncope.core.persistence.api.entity.Policy; +import org.apache.syncope.core.persistence.api.entity.SyncPolicy; +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 PolicyTest extends AbstractTest { + + @Autowired + private AnyTypeDAO anyTypeDAO; + + @Autowired + private PolicyDAO policyDAO; + + @Test + public void findAll() { + List<Policy> policies = policyDAO.findAll(); + assertNotNull(policies); + assertFalse(policies.isEmpty()); + } + + @Test + public void findById() { + Policy policy = policyDAO.find(1L); + assertNotNull("findById did not work", policy); + } + + @Test + public void findByType() { + List<? extends Policy> policies = policyDAO.find(PolicyType.SYNC); + assertNotNull("findById did not work", policies); + assertFalse(policies.isEmpty()); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidPolicy() { + PasswordPolicySpec passwordPolicy = new PasswordPolicySpec(); + passwordPolicy.setMaxLength(8); + passwordPolicy.setMinLength(6); + + SyncPolicy policy = entityFactory.newEntity(SyncPolicy.class); + policy.setSpecification(passwordPolicy); + policy.setDescription("sync policy"); + + policyDAO.save(policy); + } + + @Test + public void create() { + SyncPolicy policy = entityFactory.newEntity(SyncPolicy.class); + + final String syncURuleName = "net.tirasa.sync.correlation.TirasaURule"; + final String syncGRuleName = "net.tirasa.sync.correlation.TirasaGRule"; + + SyncPolicySpec syncPolicySpec = new SyncPolicySpec(); + + SyncPolicySpecItem item = new SyncPolicySpecItem(); + item.setAnyTypeKey(anyTypeDAO.findUser().getKey()); + item.setJavaRule(syncURuleName); + syncPolicySpec.getItems().add(item); + + item = new SyncPolicySpecItem(); + item.setAnyTypeKey(anyTypeDAO.findGroup().getKey()); + item.setJavaRule(syncGRuleName); + syncPolicySpec.getItems().add(item); + + policy.setSpecification(syncPolicySpec); + policy.setDescription("Sync policy"); + + policy = policyDAO.save(policy); + + assertNotNull(policy); + assertEquals(PolicyType.SYNC, policy.getType()); + assertEquals(syncURuleName, + (policy.getSpecification(SyncPolicySpec.class)).getItem(anyTypeDAO.findUser().getKey()).getJavaRule()); + assertEquals(syncGRuleName, + (policy.getSpecification(SyncPolicySpec.class)).getItem(anyTypeDAO.findGroup().getKey()).getJavaRule()); + } + + @Test + public void update() { + PasswordPolicySpec specification = new PasswordPolicySpec(); + specification.setMaxLength(8); + specification.setMinLength(6); + + Policy policy = policyDAO.find(2L); + assertNotNull(policy); + policy.setSpecification(specification); + + policy = policyDAO.save(policy); + + assertNotNull(policy); + assertEquals(PolicyType.PASSWORD, policy.getType()); + assertEquals((policy.getSpecification(PasswordPolicySpec.class)).getMaxLength(), 8); + assertEquals((policy.getSpecification(PasswordPolicySpec.class)).getMinLength(), 6); + } + + @Test + public void delete() { + Policy policy = policyDAO.find(1L); + assertNotNull("find to delete did not work", policy); + + policyDAO.delete(policy); + + Policy actual = policyDAO.find(1L); + assertNull("delete did not work", actual); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RealmTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RealmTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RealmTest.java new file mode 100644 index 0000000..3fef2ce --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RealmTest.java @@ -0,0 +1,178 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.syncope.common.lib.SyncopeConstants; +import org.apache.syncope.common.lib.types.EntityViolationType; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +import org.apache.syncope.core.persistence.api.dao.MalformedPathException; +import org.apache.syncope.core.persistence.api.dao.PolicyDAO; +import org.apache.syncope.core.persistence.api.dao.RealmDAO; +import org.apache.syncope.core.persistence.api.entity.AccountPolicy; +import org.apache.syncope.core.persistence.api.entity.PasswordPolicy; +import org.apache.syncope.core.persistence.api.entity.Realm; +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 PolicyDAO policyDAO; + + @Test + public void getRoot() { + assertNotNull(realmDAO.getRoot()); + } + + @Test + public void find() { + Realm realm = realmDAO.find(1L); + assertNotNull(realm); + assertEquals(SyncopeConstants.ROOT_REALM, realm.getName()); + assertEquals(SyncopeConstants.ROOT_REALM, realm.getFullPath()); + + realm = realmDAO.find(3L); + assertNotNull(realm); + assertEquals("even", realm.getName()); + assertEquals("/even", realm.getFullPath()); + assertEquals(1, realm.getParent().getKey(), 0); + assertEquals(realmDAO.getRoot(), realm.getParent()); + + realm = realmDAO.find("/even/two"); + assertNotNull(realm); + assertEquals(4, realm.getKey(), 0); + assertEquals("two", realm.getName()); + assertEquals("/even/two", realm.getFullPath()); + } + + @Test(expected = MalformedPathException.class) + public void findInvalidPath() { + realmDAO.find("even/two"); + } + + @Test + public void findChildren() { + List<Realm> children = realmDAO.findChildren(realmDAO.find(SyncopeConstants.ROOT_REALM)); + assertEquals(2, children.size()); + assertTrue(children.contains(realmDAO.find("/odd"))); + assertTrue(children.contains(realmDAO.find("/even"))); + + children = realmDAO.findChildren(realmDAO.find("/odd")); + assertTrue(children.isEmpty()); + } + + @Test + public void findDescendants() { + assertTrue(CollectionUtils.disjunction(realmDAO.findAll(), realmDAO.findDescendants(realmDAO.getRoot())). + isEmpty()); + } + + @Test + public void findAll() { + List<Realm> list = realmDAO.findAll(); + assertNotNull(list); + assertFalse(list.isEmpty()); + for (Realm realm : list) { + assertNotNull(realm); + } + } + + @Test + public void save() { + Realm realm = entityFactory.newEntity(Realm.class); + realm.setName("last"); + realm.setParent(realmDAO.find("/even/two")); + assertNull(realm.getKey()); + + Realm actual = realmDAO.save(realm); + assertNotNull(actual.getKey()); + assertEquals("last", actual.getName()); + assertEquals("/even/two/last", actual.getFullPath()); + assertEquals(realmDAO.find("/even/two"), actual.getParent()); + assertEquals(5L, realm.getAccountPolicy().getKey(), 0); + assertEquals(2L, realm.getPasswordPolicy().getKey(), 0); + + realm = actual; + realm.setAccountPolicy((AccountPolicy) policyDAO.find(6L)); + realm.setPasswordPolicy((PasswordPolicy) policyDAO.find(4L)); + + actual = realmDAO.save(realm); + assertEquals(6L, actual.getAccountPolicy().getKey(), 0); + assertEquals(4L, actual.getPasswordPolicy().getKey(), 0); + } + + @Test + public void saveInvalidName() { + Realm realm = entityFactory.newEntity(Realm.class); + realm.setName(" a name"); + realm.setParent(realmDAO.getRoot()); + + try { + realmDAO.save(realm); + fail(); + } catch (InvalidEntityException e) { + assertTrue(e.hasViolation(EntityViolationType.InvalidRealm)); + } + } + + @Test + public void saveNullParent() { + Realm realm = entityFactory.newEntity(Realm.class); + realm.setName("name"); + realm.setParent(null); + + try { + realmDAO.save(realm); + fail(); + } catch (InvalidEntityException e) { + assertTrue(e.hasViolation(EntityViolationType.InvalidRealm)); + } + } + + @Test + public void delete() { + Realm realm = entityFactory.newEntity(Realm.class); + realm.setName("name"); + realm.setParent(realmDAO.getRoot()); + + Realm actual = realmDAO.save(realm); + assertNotNull(actual); + + Long key = actual.getKey(); + assertNotNull(realmDAO.find(key)); + + realmDAO.delete(key); + assertNull(realmDAO.find(key)); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RelationshipTypeTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RelationshipTypeTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RelationshipTypeTest.java new file mode 100644 index 0000000..9aee7f1 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RelationshipTypeTest.java @@ -0,0 +1,104 @@ +/* + * 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.inner; + +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.attrvalue.validation.InvalidEntityException; +import org.apache.syncope.core.persistence.api.dao.AnyObjectDAO; +import org.apache.syncope.core.persistence.api.dao.RelationshipTypeDAO; +import org.apache.syncope.core.persistence.api.entity.RelationshipType; +import org.apache.syncope.core.persistence.api.entity.anyobject.AnyObject; +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 RelationshipTypeTest extends AbstractTest { + + @Autowired + private RelationshipTypeDAO relationshipTypeDAO; + + @Autowired + private AnyObjectDAO anyObjectDAO; + + @Test + public void find() { + RelationshipType inclusion = relationshipTypeDAO.find("inclusion"); + assertNotNull(inclusion); + assertEquals("inclusion", inclusion.getKey()); + } + + @Test + public void findAll() { + List<RelationshipType> list = relationshipTypeDAO.findAll(); + assertFalse(list.isEmpty()); + } + + @Test + public void save() { + RelationshipType newType = entityFactory.newEntity(RelationshipType.class); + newType.setKey("new type"); + newType.setDescription("description"); + + newType = relationshipTypeDAO.save(newType); + assertNotNull(newType); + assertEquals("description", newType.getDescription()); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidName() { + RelationshipType newType = entityFactory.newEntity(RelationshipType.class); + newType.setKey("membership"); + relationshipTypeDAO.save(newType); + } + + @Test + public void delete() { + RelationshipType type = relationshipTypeDAO.find("neighborhood"); + assertNotNull(type); + + relationshipTypeDAO.delete(type.getKey()); + assertNull(relationshipTypeDAO.find("neighborhood")); + } + + @Test + public void deleteOnAnyObject() { + RelationshipType neighborhood = relationshipTypeDAO.find("neighborhood"); + assertNotNull(neighborhood); + + AnyObject anyObject = anyObjectDAO.find(1L); + assertNotNull(anyObject); + assertNotNull(anyObject.getRelationship(neighborhood)); + + relationshipTypeDAO.delete("neighborhood"); + + relationshipTypeDAO.flush(); + + anyObject = anyObjectDAO.find(1L); + assertNotNull(anyObject); + assertTrue(anyObject.getRelationships().isEmpty()); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ReportTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ReportTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ReportTest.java new file mode 100644 index 0000000..4318813 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ReportTest.java @@ -0,0 +1,83 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.List; +import org.apache.syncope.common.lib.report.UserReportletConf; +import org.apache.syncope.core.persistence.api.dao.ReportDAO; +import org.apache.syncope.core.persistence.api.entity.Report; +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 ReportTest extends AbstractTest { + + @Autowired + private ReportDAO reportDAO; + + @Test + public void find() { + Report report = reportDAO.find(1L); + assertNotNull(report); + + report = reportDAO.find(10L); + assertNull(report); + } + + @Test + public void findAll() { + List<Report> reports = reportDAO.findAll(); + assertNotNull(reports); + assertEquals(1, reports.size()); + } + + @Test + public void save() { + int beforeCount = reportDAO.count(); + + Report report = entityFactory.newEntity(Report.class); + report.setName("new report"); + report.addReportletConf(new UserReportletConf("first")); + report.addReportletConf(new UserReportletConf("second")); + + report = reportDAO.save(report); + assertNotNull(report); + assertNotNull(report.getKey()); + + int afterCount = reportDAO.count(); + assertEquals(afterCount, beforeCount + 1); + } + + @Test + public void delete() { + Report report = reportDAO.find(1L); + assertNotNull(report); + + reportDAO.delete(1L); + + report = reportDAO.find(1L); + assertNull(report); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ResourceTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ResourceTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ResourceTest.java new file mode 100644 index 0000000..e5cee24 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/ResourceTest.java @@ -0,0 +1,372 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.Predicate; +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.common.lib.types.EntityViolationType; +import org.apache.syncope.common.lib.types.IntMappingType; +import org.apache.syncope.common.lib.types.MappingPurpose; +import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException; +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.entity.ConnInstance; +import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource; +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.jpa.AbstractTest; +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 ExternalResourceDAO resourceDAO; + + @Autowired + private AnyTypeDAO anyTypeDAO; + + @Test + public void findById() { + ExternalResource resource = resourceDAO.find("ws-target-resource-1"); + assertNotNull("findById did not work", resource); + + ConnInstance connector = resource.getConnector(); + assertNotNull("connector not found", connector); + assertEquals("invalid connector name", + "net.tirasa.connid.bundles.soap.WebServiceConnector", connector.getConnectorName()); + assertEquals("invalid bundle name", "net.tirasa.connid.bundles.soap", connector.getBundleName()); + + Mapping mapping = resource.getProvision(anyTypeDAO.findUser()).getMapping(); + assertFalse("no mapping specified", mapping.getItems().isEmpty()); + + assertTrue(CollectionUtils.exists(mapping.getItems(), new Predicate<MappingItem>() { + + @Override + public boolean evaluate(final MappingItem item) { + return 100 == item.getKey(); + } + })); + } + + @Test + public void findAll() { + List<ExternalResource> resources = resourceDAO.findAll(); + assertNotNull(resources); + assertEquals(19, resources.size()); + } + + @Test + public void findAllByPriority() { + List<ExternalResource> resources = resourceDAO.findAllByPriority(); + assertNotNull(resources); + assertFalse(resources.isEmpty()); + } + + @Test + public void getConnObjectKey() { + ExternalResource resource = resourceDAO.find("ws-target-resource-2"); + assertNotNull(resource); + assertEquals("fullname", + resource.getProvision(anyTypeDAO.findUser()).getMapping().getConnObjectKeyItem().getIntAttrName()); + } + + @Test + public void save() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save"); + resource.setPropagationPriority(2); + resource.setPropagationPrimary(true); + + 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); + + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setExtAttrName("username"); + connObjectKey.setIntAttrName("fullname"); + connObjectKey.setIntMappingType(IntMappingType.UserKey); + connObjectKey.setPurpose(MappingPurpose.BOTH); + mapping.setConnObjectKeyItem(connObjectKey); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + resource.setConnector(connector); + + // save the resource + ExternalResource actual = resourceDAO.save(resource); + + assertNotNull(actual); + assertNotNull(actual.getConnector()); + assertNotNull(actual.getProvision(anyTypeDAO.findUser()).getMapping()); + assertFalse(actual.getProvision(anyTypeDAO.findUser()).getMapping().getItems().isEmpty()); + assertEquals(Integer.valueOf(2), actual.getPropagationPriority()); + assertTrue(actual.isPropagationPrimary()); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidMappingIntAttr() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save-invalid"); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + 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); + + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setConnObjectKey(true); + connObjectKey.setIntMappingType(IntMappingType.UserPlainSchema); + mapping.add(connObjectKey); + + // save the resource + resourceDAO.save(resource); + } + + @Test(expected = IllegalArgumentException.class) + public void saveInvalidConnObjectKeyMapping() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save-invalid"); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + 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); + + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setConnObjectKey(true); + connObjectKey.setIntMappingType(IntMappingType.UserVirtualSchema); + mapping.setConnObjectKeyItem(connObjectKey); + + // save the resource + resourceDAO.save(resource); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidMappingExtAttr() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save-invalid"); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + 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); + + MappingItem item = entityFactory.newEntity(MappingItem.class); + item.setConnObjectKey(true); + item.setIntAttrName("fullname"); + item.setIntMappingType(IntMappingType.UserPlainSchema); + mapping.add(item); + + item = entityFactory.newEntity(MappingItem.class); + item.setIntAttrName("userId"); + item.setIntMappingType(IntMappingType.UserPlainSchema); + mapping.add(item); + + resourceDAO.save(resource); + } + + @Test(expected = InvalidEntityException.class) + public void saveInvalidProvision() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("invalidProvision"); + + 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); + + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setExtAttrName("username"); + connObjectKey.setIntAttrName("fullname"); + connObjectKey.setIntMappingType(IntMappingType.UserKey); + connObjectKey.setPurpose(MappingPurpose.BOTH); + mapping.setConnObjectKeyItem(connObjectKey); + + provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findGroup()); + provision.setObjectClass(ObjectClass.ACCOUNT); + provision.setResource(resource); + resource.add(provision); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + resource.setConnector(connector); + + // save the resource + resourceDAO.save(resource); + } + + @Test + public void saveWithGroupMappingType() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save-invalid"); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + 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); + + MappingItem item = entityFactory.newEntity(MappingItem.class); + item.setIntAttrName("fullname"); + item.setExtAttrName("fullname"); + item.setIntMappingType(IntMappingType.UserPlainSchema); + item.setPurpose(MappingPurpose.BOTH); + mapping.setConnObjectKeyItem(item); + + item = entityFactory.newEntity(MappingItem.class); + item.setIntAttrName("icon"); + item.setExtAttrName("icon"); + item.setIntMappingType(IntMappingType.GroupPlainSchema); + item.setPurpose(MappingPurpose.BOTH); + mapping.add(item); + + item = entityFactory.newEntity(MappingItem.class); + item.setIntAttrName("mderiveddata"); + item.setExtAttrName("mderiveddata"); + item.setIntMappingType(IntMappingType.AnyObjectDerivedSchema); + item.setPurpose(MappingPurpose.BOTH); + mapping.add(item); + + // save the resource + ExternalResource actual = resourceDAO.save(resource); + assertNotNull(actual); + + int items = 0; + for (MappingItem mapItem : actual.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) { + items++; + + if ("icon".equals(mapItem.getIntAttrName())) { + assertTrue(IntMappingType.contains(AnyTypeKind.GROUP, mapItem.getIntMappingType().toString())); + } + if ("mderiveddata".equals(mapItem.getIntAttrName())) { + assertTrue(IntMappingType.contains(AnyTypeKind.ANY_OBJECT, mapItem.getIntMappingType().toString())); + } + } + assertEquals(3, items); + } + + @Test + public void delete() { + ExternalResource resource = resourceDAO.find("ws-target-resource-2"); + assertNotNull(resource); + + resourceDAO.delete(resource.getKey()); + + ExternalResource actual = resourceDAO.find("ws-target-resource-2"); + assertNull(actual); + } + + @Test + public void issueSYNCOPE418() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); + + try { + resourceDAO.save(resource); + fail(); + } catch (InvalidEntityException e) { + assertTrue(e.hasViolation(EntityViolationType.InvalidName)); + } + } + + @Test(expected = InvalidEntityException.class) + public void issueSYNCOPE645() { + ExternalResource resource = entityFactory.newEntity(ExternalResource.class); + resource.setKey("ws-target-resource-basic-save-invalid"); + + ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); + 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); + + final MappingItem item = entityFactory.newEntity(MappingItem.class); + item.setIntAttrName("icon"); + item.setExtAttrName("icon"); + item.setIntMappingType(IntMappingType.GroupPlainSchema); + item.setPurpose(MappingPurpose.BOTH); + mapping.setConnObjectKeyItem(item); + + // save the resource + ExternalResource actual = resourceDAO.save(resource); + assertNotNull(actual); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RoleTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RoleTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RoleTest.java new file mode 100644 index 0000000..bf2c012 --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/RoleTest.java @@ -0,0 +1,89 @@ +/* + * 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.inner; + +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.Entitlement; +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.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 RoleTest extends AbstractTest { + + @Autowired + private RoleDAO roleDAO; + + @Autowired + private RealmDAO realmDAO; + + @Test + public void find() { + Role role1 = roleDAO.find(2L); + assertNotNull(role1); + assertNotNull(role1.getName()); + assertFalse(role1.getRealms().isEmpty()); + assertFalse(role1.getEntitlements().isEmpty()); + assertTrue(role1.getEntitlements().contains(Entitlement.USER_LIST)); + + Role role2 = roleDAO.find(role1.getName()); + assertEquals(role1, role2); + } + + @Test + public void findAll() { + List<Role> list = roleDAO.findAll(); + assertNotNull(list); + assertFalse(list.isEmpty()); + for (Role role : list) { + assertNotNull(role); + } + } + + @Test + public void save() { + 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); + + Role actual = roleDAO.save(role); + assertNotNull(actual); + } + + @Test + public void delete() { + assertNotNull(roleDAO.find(3L)); + + roleDAO.delete(3L); + assertNull(roleDAO.find(3L)); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d8927ef4/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/SecurityQuestionTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/SecurityQuestionTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/SecurityQuestionTest.java new file mode 100644 index 0000000..f17146e --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/inner/SecurityQuestionTest.java @@ -0,0 +1,68 @@ +/* + * 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.inner; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.List; +import org.apache.syncope.core.persistence.api.dao.SecurityQuestionDAO; +import org.apache.syncope.core.persistence.api.entity.user.SecurityQuestion; +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; + + @Test + public void find() { + SecurityQuestion securityQuestion = securityQuestionDAO.find(1L); + assertNotNull(securityQuestion); + assertNotNull(securityQuestion.getContent()); + } + + @Test + public void findAll() { + List<SecurityQuestion> securityQuestions = securityQuestionDAO.findAll(); + assertNotNull(securityQuestions); + assertFalse(securityQuestions.isEmpty()); + } + + @Test + public void save() { + SecurityQuestion securityQuestion = entityFactory.newEntity(SecurityQuestion.class); + securityQuestion.setContent("What is your favorite pet's name?"); + + SecurityQuestion actual = securityQuestionDAO.save(securityQuestion); + assertNotNull(actual); + assertNotNull(actual.getKey()); + } + + @Test + public void delete() { + securityQuestionDAO.delete(1L); + assertNull(securityQuestionDAO.find(1L)); + } +}
