http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AnySearchTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AnySearchTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AnySearchTest.java new file mode 100644 index 0000000..9d253da --- /dev/null +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AnySearchTest.java @@ -0,0 +1,500 @@ +/* + * 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.entity; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.Predicate; +import org.apache.cxf.ws.addressing.v200403.Relationship; +import org.apache.syncope.common.lib.SyncopeConstants; +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.core.persistence.api.dao.AnyObjectDAO; +import org.apache.syncope.core.persistence.api.dao.GroupDAO; +import org.apache.syncope.core.persistence.api.dao.AnySearchDAO; +import org.apache.syncope.core.persistence.api.dao.UserDAO; +import org.apache.syncope.core.persistence.api.dao.search.AttributeCond; +import org.apache.syncope.core.persistence.api.dao.search.MembershipCond; +import org.apache.syncope.core.persistence.api.dao.search.OrderByClause; +import org.apache.syncope.core.persistence.api.dao.search.ResourceCond; +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.dao.search.AnyCond; +import org.apache.syncope.core.persistence.api.dao.search.RelationshipCond; +import org.apache.syncope.core.persistence.api.entity.anyobject.AnyObject; +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 AnyObjectDAO anyObjectDAO; + + @Autowired + private UserDAO userDAO; + + @Autowired + private GroupDAO groupDAO; + + @Autowired + private AnySearchDAO searchDAO; + + @Test + public void anyObjectMatch() { + AnyObject anyObject = anyObjectDAO.find(1L); + assertNotNull(anyObject); + + RelationshipCond cond = new RelationshipCond(); + cond.setAnyObjectKey(2L); + assertTrue(searchDAO.matches(anyObject, SearchCond.getLeafCond(cond), AnyTypeKind.ANY_OBJECT)); + } + + @Test + public void userMatch() { + User user = userDAO.find(1L); + assertNotNull(user); + + MembershipCond groupCond = new MembershipCond(); + groupCond.setGroupKey(5L); + assertFalse(searchDAO.matches(user, SearchCond.getLeafCond(groupCond), AnyTypeKind.USER)); + + groupCond.setGroupKey(1L); + assertTrue(searchDAO.matches(user, SearchCond.getLeafCond(groupCond), AnyTypeKind.USER)); + + RoleCond roleCond = new RoleCond(); + roleCond.setRoleKey(3L); + assertTrue(searchDAO.matches(user, SearchCond.getLeafCond(roleCond), AnyTypeKind.USER)); + } + + @Test + public void groupMatch() { + Group group = groupDAO.find(1L); + assertNotNull(group); + + AttributeCond attrCond = new AttributeCond(); + attrCond.setSchema("show"); + attrCond.setType(AttributeCond.Type.ISNOTNULL); + + assertTrue(searchDAO.matches(group, SearchCond.getLeafCond(attrCond), AnyTypeKind.GROUP)); + } + + @Test + public void searchWithLikeCondition() { + AttributeCond fullnameLeafCond = new AttributeCond(AttributeCond.Type.LIKE); + fullnameLeafCond.setSchema("fullname"); + fullnameLeafCond.setExpression("%o%"); + + MembershipCond groupCond = new MembershipCond(); + groupCond.setGroupKey(1L); + + AttributeCond loginDateCond = new AttributeCond(AttributeCond.Type.EQ); + loginDateCond.setSchema("loginDate"); + loginDateCond.setExpression("2009-05-26"); + + SearchCond subCond = SearchCond.getAndCond( + SearchCond.getLeafCond(fullnameLeafCond), SearchCond.getLeafCond(groupCond)); + + assertTrue(subCond.isValid()); + + SearchCond cond = SearchCond.getAndCond(subCond, SearchCond.getLeafCond(loginDateCond)); + + assertTrue(cond.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, cond, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + } + + @Test + public void searchWithNotCondition() { + AttributeCond fullnameLeafCond = new AttributeCond(AttributeCond.Type.EQ); + fullnameLeafCond.setSchema("fullname"); + fullnameLeafCond.setExpression("Giuseppe Verdi"); + + SearchCond cond = SearchCond.getNotLeafCond(fullnameLeafCond); + assertTrue(cond.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, cond, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(4, users.size()); + + Set<Long> ids = new HashSet<>(users.size()); + for (User user : users) { + ids.add(user.getKey()); + } + assertTrue(ids.contains(1L)); + assertTrue(ids.contains(3L)); + } + + @Test + public void searchByBoolean() { + 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(Long.valueOf(4L), users.get(0).getKey()); + } + + @Test + public void searchByPageAndSize() { + AttributeCond fullnameLeafCond = new AttributeCond(AttributeCond.Type.LIKE); + fullnameLeafCond.setSchema("fullname"); + fullnameLeafCond.setExpression("%o%"); + + MembershipCond groupCond = new MembershipCond(); + groupCond.setGroupKey(1L); + + AttributeCond loginDateCond = new AttributeCond(AttributeCond.Type.EQ); + loginDateCond.setSchema("loginDate"); + loginDateCond.setExpression("2009-05-26"); + + SearchCond subCond = SearchCond.getAndCond( + SearchCond.getLeafCond(fullnameLeafCond), SearchCond.getLeafCond(groupCond)); + + assertTrue(subCond.isValid()); + + SearchCond cond = SearchCond.getAndCond(subCond, SearchCond.getLeafCond(loginDateCond)); + + assertTrue(cond.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + cond, 1, 2, Collections.<OrderByClause>emptyList(), + AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + + users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + cond, 2, 2, Collections.<OrderByClause>emptyList(), + AnyTypeKind.USER); + assertNotNull(users); + assertTrue(users.isEmpty()); + } + + @Test + public void searchByGroup() { + MembershipCond groupCond = new MembershipCond(); + groupCond.setGroupKey(1L); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + SearchCond.getLeafCond(groupCond), AnyTypeKind.USER); + assertNotNull(users); + assertEquals(2, users.size()); + + groupCond = new MembershipCond(); + groupCond.setGroupKey(5L); + + users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + SearchCond.getNotLeafCond(groupCond), AnyTypeKind.USER); + assertNotNull(users); + assertEquals(5, users.size()); + } + + @Test + public void searchByRole() { + RoleCond roleCond = new RoleCond(); + roleCond.setRoleKey(3L); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + SearchCond.getLeafCond(roleCond), AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + } + + @Test + public void searchByIsNull() { + AttributeCond coolLeafCond = new AttributeCond(AttributeCond.Type.ISNULL); + coolLeafCond.setSchema("cool"); + + List<User> users = searchDAO.search( + SyncopeConstants.FULL_ADMIN_REALMS, SearchCond.getLeafCond(coolLeafCond), AnyTypeKind.USER); + assertNotNull(users); + assertEquals(4, users.size()); + + coolLeafCond = new AttributeCond(AttributeCond.Type.ISNOTNULL); + coolLeafCond.setSchema("cool"); + + users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + SearchCond.getLeafCond(coolLeafCond), AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + } + + @Test + public void searchByResource() { + ResourceCond ws2 = new ResourceCond(); + ws2.setResourceName("ws-target-resource-2"); + + ResourceCond ws1 = new ResourceCond(); + ws1.setResourceName("ws-target-resource-list-mappings-2"); + + SearchCond searchCondition = SearchCond.getAndCond(SearchCond.getNotLeafCond(ws2), SearchCond.getLeafCond(ws1)); + assertTrue(searchCondition.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + } + + @Test + public void searchByBooleanSubjectCond() { + AttributeCond booleanCond = new AttributeCond(AnyCond.Type.EQ); + booleanCond.setSchema("show"); + booleanCond.setExpression("true"); + + List<Group> matchingGroups = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + SearchCond.getLeafCond(booleanCond), AnyTypeKind.GROUP); + assertNotNull(matchingGroups); + assertFalse(matchingGroups.isEmpty()); + } + + @Test + public void searchByUsernameAndKey() { + AnyCond usernameLeafCond = new AnyCond(AnyCond.Type.LIKE); + usernameLeafCond.setSchema("username"); + usernameLeafCond.setExpression("%ini"); + + AnyCond idRightCond = new AnyCond(AnyCond.Type.LT); + idRightCond.setSchema("key"); + idRightCond.setExpression("2"); + + SearchCond searchCondition = SearchCond.getAndCond( + SearchCond.getLeafCond(usernameLeafCond), + SearchCond.getLeafCond(idRightCond)); + + List<User> matchingUsers = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, AnyTypeKind.USER); + + assertNotNull(matchingUsers); + assertEquals(1, matchingUsers.size()); + assertEquals("rossini", matchingUsers.iterator().next().getUsername()); + assertEquals(1L, matchingUsers.iterator().next().getKey(), 0); + } + + @Test + public void searchByGroupNameAndKey() { + AnyCond groupNameLeafCond = new AnyCond(AnyCond.Type.EQ); + groupNameLeafCond.setSchema("name"); + groupNameLeafCond.setExpression("root"); + + AnyCond idRightCond = new AnyCond(AnyCond.Type.LT); + idRightCond.setSchema("key"); + idRightCond.setExpression("2"); + + SearchCond searchCondition = SearchCond.getAndCond( + SearchCond.getLeafCond(groupNameLeafCond), + SearchCond.getLeafCond(idRightCond)); + + assertTrue(searchCondition.isValid()); + + List<Group> matchingGroups = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, AnyTypeKind.GROUP); + + assertNotNull(matchingGroups); + assertEquals(1, matchingGroups.size()); + assertEquals("root", matchingGroups.iterator().next().getName()); + assertEquals(1L, matchingGroups.iterator().next().getKey(), 0); + } + + @Test + public void searchByUsernameAndFullname() { + AnyCond usernameLeafCond = new AnyCond(AnyCond.Type.EQ); + usernameLeafCond.setSchema("username"); + usernameLeafCond.setExpression("rossini"); + + AttributeCond idRightCond = new AttributeCond(AttributeCond.Type.LIKE); + idRightCond.setSchema("fullname"); + idRightCond.setExpression("Giuseppe V%"); + + SearchCond searchCondition = SearchCond.getOrCond( + SearchCond.getLeafCond(usernameLeafCond), + SearchCond.getLeafCond(idRightCond)); + + List<User> matchingUsers = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, AnyTypeKind.USER); + assertNotNull(matchingUsers); + assertEquals(2, matchingUsers.size()); + } + + @Test + public void searchById() { + AnyCond idLeafCond = new AnyCond(AnyCond.Type.LT); + idLeafCond.setSchema("id"); + idLeafCond.setExpression("2"); + + SearchCond searchCondition = SearchCond.getLeafCond(idLeafCond); + assertTrue(searchCondition.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + assertEquals(1L, users.iterator().next().getKey(), 0); + + idLeafCond = new AnyCond(AnyCond.Type.LT); + idLeafCond.setSchema("id"); + idLeafCond.setExpression("4"); + + searchCondition = SearchCond.getNotLeafCond(idLeafCond); + assertTrue(searchCondition.isValid()); + + users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(2, users.size()); + assertTrue(CollectionUtils.exists(users, new Predicate<User>() { + + @Override + public boolean evaluate(User user) { + return user.getKey() == 4; + } + })); + } + + @Test + public void userOrderBy() { + AnyCond usernameLeafCond = new AnyCond(AnyCond.Type.EQ); + usernameLeafCond.setSchema("username"); + usernameLeafCond.setExpression("rossini"); + AttributeCond idRightCond = new AttributeCond(AttributeCond.Type.LIKE); + idRightCond.setSchema("fullname"); + idRightCond.setExpression("Giuseppe V%"); + SearchCond searchCondition = SearchCond.getOrCond( + SearchCond.getLeafCond(usernameLeafCond), SearchCond.getLeafCond(idRightCond)); + + List<OrderByClause> orderByClauses = new ArrayList<>(); + OrderByClause orderByClause = new OrderByClause(); + orderByClause.setField("username"); + orderByClause.setDirection(OrderByClause.Direction.DESC); + orderByClauses.add(orderByClause); + orderByClause = new OrderByClause(); + orderByClause.setField("fullname"); + orderByClause.setDirection(OrderByClause.Direction.ASC); + orderByClauses.add(orderByClause); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, orderByClauses, AnyTypeKind.USER); + assertEquals(searchDAO.count(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER), + users.size()); + } + + @Test + public void groupOrderBy() { + AnyCond idLeafCond = new AnyCond(AnyCond.Type.LIKE); + idLeafCond.setSchema("name"); + idLeafCond.setExpression("%r"); + SearchCond searchCondition = SearchCond.getLeafCond(idLeafCond); + assertTrue(searchCondition.isValid()); + + OrderByClause orderByClause = new OrderByClause(); + orderByClause.setField("name"); + + List<Group> groups = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, Collections.singletonList(orderByClause), AnyTypeKind.GROUP); + assertEquals(searchDAO.count(SyncopeConstants.FULL_ADMIN_REALMS, + searchCondition, AnyTypeKind.GROUP), + groups.size()); + } + + @Test + public void issue202() { + ResourceCond ws2 = new ResourceCond(); + ws2.setResourceName("ws-target-resource-2"); + + ResourceCond ws1 = new ResourceCond(); + ws1.setResourceName("ws-target-resource-list-mappings-1"); + + SearchCond searchCondition = + SearchCond.getAndCond(SearchCond.getNotLeafCond(ws2), SearchCond.getNotLeafCond(ws1)); + assertTrue(searchCondition.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(2, users.size()); + assertTrue(CollectionUtils.exists(users, new Predicate<User>() { + + @Override + public boolean evaluate(User user) { + return user.getKey() == 4; + } + })); + } + + @Test + public void issue242() { + AnyCond cond = new AnyCond(AttributeCond.Type.LIKE); + cond.setSchema("id"); + cond.setExpression("test%"); + + SearchCond searchCondition = SearchCond.getLeafCond(cond); + assertTrue(searchCondition.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertTrue(users.isEmpty()); + } + + @Test + public void issueSYNCOPE46() { + AnyCond cond = new AnyCond(AttributeCond.Type.LIKE); + cond.setSchema("username"); + cond.setExpression("%ossin%"); + + SearchCond searchCondition = SearchCond.getLeafCond(cond); + assertTrue(searchCondition.isValid()); + + List<User> users = searchDAO.search(SyncopeConstants.FULL_ADMIN_REALMS, searchCondition, AnyTypeKind.USER); + assertNotNull(users); + assertEquals(1, users.size()); + } + + @Test + public void issueSYNCOPE433() { + AttributeCond isNullCond = new AttributeCond(AttributeCond.Type.ISNULL); + isNullCond.setSchema("loginDate"); + + AnyCond likeCond = new AnyCond(AttributeCond.Type.LIKE); + likeCond.setSchema("username"); + likeCond.setExpression("%ossin%"); + + SearchCond searchCond = SearchCond.getOrCond( + SearchCond.getLeafCond(isNullCond), SearchCond.getLeafCond(likeCond)); + + Integer count = searchDAO.count(SyncopeConstants.FULL_ADMIN_REALMS, searchCond, AnyTypeKind.USER); + assertNotNull(count); + assertTrue(count > 0); + } +}
http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AttrTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AttrTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AttrTest.java index 4ad4dd0..a0d12a6 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AttrTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/AttrTest.java @@ -29,7 +29,7 @@ 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.AttributableType; +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; @@ -37,10 +37,10 @@ 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.UPlainSchema; 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; @@ -78,7 +78,7 @@ public class AttrTest extends AbstractTest { public void save() throws ClassNotFoundException { User user = userDAO.find(1L); - UPlainSchema emailSchema = plainSchemaDAO.find("email", UPlainSchema.class); + PlainSchema emailSchema = plainSchemaDAO.find("email"); assertNotNull(emailSchema); UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); @@ -87,15 +87,15 @@ public class AttrTest extends AbstractTest { Exception thrown = null; try { - attribute.addValue("[email protected]", attrUtilsFactory.getInstance(AttributableType.USER)); - attribute.addValue("[email protected]", attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add("[email protected]", anyUtilsFactory.getInstance(AnyTypeKind.USER)); + attribute.add("[email protected]", anyUtilsFactory.getInstance(AnyTypeKind.USER)); } catch (ValidationException e) { thrown = e; } assertNull("no validation exception expected here ", thrown); try { - attribute.addValue("http://www.apache.org";, attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add("http://www.apache.org";, anyUtilsFactory.getInstance(AnyTypeKind.USER)); } catch (ValidationException e) { thrown = e; } @@ -105,8 +105,9 @@ public class AttrTest extends AbstractTest { @Test public void saveWithEnum() throws ClassNotFoundException { User user = userDAO.find(1L); + assertNotNull(user); - UPlainSchema gender = plainSchemaDAO.find("gender", UPlainSchema.class); + PlainSchema gender = plainSchemaDAO.find("gender"); assertNotNull(gender); assertNotNull(gender.getType()); assertNotNull(gender.getEnumerationValues()); @@ -114,18 +115,18 @@ public class AttrTest extends AbstractTest { UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); attribute.setSchema(gender); attribute.setOwner(user); - user.addPlainAttr(attribute); + user.add(attribute); Exception thrown = null; try { - attribute.addValue("A", attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add("A", anyUtilsFactory.getInstance(AnyTypeKind.USER)); } catch (ValidationException e) { thrown = e; } assertNotNull("validation exception expected here ", thrown); - attribute.addValue("M", attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add("M", anyUtilsFactory.getInstance(AnyTypeKind.USER)); InvalidEntityException iee = null; try { @@ -140,10 +141,10 @@ public class AttrTest extends AbstractTest { public void validateAndSave() { User user = userDAO.find(1L); - final UPlainSchema emailSchema = plainSchemaDAO.find("email", UPlainSchema.class); + PlainSchema emailSchema = plainSchemaDAO.find("email"); assertNotNull(emailSchema); - final UPlainSchema fullnameSchema = plainSchemaDAO.find("fullname", UPlainSchema.class); + PlainSchema fullnameSchema = plainSchemaDAO.find("fullname"); assertNotNull(fullnameSchema); UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); @@ -156,7 +157,7 @@ public class AttrTest extends AbstractTest { attribute.setUniqueValue(uauv); - user.addPlainAttr(attribute); + user.add(attribute); InvalidEntityException iee = null; try { @@ -169,23 +170,23 @@ public class AttrTest extends AbstractTest { // for attribute assertTrue(iee.hasViolation(EntityViolationType.InvalidValueList)); // for uauv - assertTrue(iee.hasViolation(EntityViolationType.InvalidUPlainSchema)); + assertTrue(iee.hasViolation(EntityViolationType.InvalidPlainSchema)); } @Test public void saveWithEncrypted() throws Exception { User user = userDAO.find(1L); - final UPlainSchema obscureSchema = plainSchemaDAO.find("obscure", UPlainSchema.class); + PlainSchema obscureSchema = plainSchemaDAO.find("obscure"); assertNotNull(obscureSchema); assertNotNull(obscureSchema.getSecretKey()); assertNotNull(obscureSchema.getCipherAlgorithm()); UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); attribute.setSchema(obscureSchema); - attribute.addValue("testvalue", attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add("testvalue", anyUtilsFactory.getInstance(AnyTypeKind.USER)); attribute.setOwner(user); - user.addPlainAttr(attribute); + user.add(attribute); userDAO.save(user); @@ -200,7 +201,7 @@ public class AttrTest extends AbstractTest { public void saveWithBinary() throws UnsupportedEncodingException { User user = userDAO.find(1L); - final UPlainSchema photoSchema = plainSchemaDAO.find("photo", UPlainSchema.class); + PlainSchema photoSchema = plainSchemaDAO.find("photo"); assertNotNull(photoSchema); assertNotNull(photoSchema.getMimeType()); @@ -210,9 +211,9 @@ public class AttrTest extends AbstractTest { UPlainAttr attribute = entityFactory.newEntity(UPlainAttr.class); attribute.setSchema(photoSchema); - attribute.addValue(photoB64Value, attrUtilsFactory.getInstance(AttributableType.USER)); + attribute.add(photoB64Value, anyUtilsFactory.getInstance(AnyTypeKind.USER)); attribute.setOwner(user); - user.addPlainAttr(attribute); + user.add(attribute); userDAO.save(user); @@ -229,7 +230,7 @@ public class AttrTest extends AbstractTest { plainAttrDAO.delete(attribute.getKey(), UPlainAttr.class); - UPlainSchema schema = plainSchemaDAO.find(attrSchemaName, UPlainSchema.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/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ConfTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ConfTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ConfTest.java index 2539a44..606c417 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ConfTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ConfTest.java @@ -25,14 +25,15 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import org.apache.syncope.common.lib.types.AttrSchemaType; -import org.apache.syncope.common.lib.types.AttributableType; 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.ConfDAO; import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO; +import org.apache.syncope.core.persistence.api.entity.PlainAttrUniqueValue; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttr; -import org.apache.syncope.core.persistence.api.entity.conf.CPlainSchema; import org.apache.syncope.core.persistence.jpa.AbstractTest; +import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrValue; import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.transaction.annotation.Transactional; @@ -60,10 +61,21 @@ public class ConfTest extends AbstractTest { assertNull(conf); } + private void add(final CPlainAttr newAttr, final String value) { + JPACPlainAttrValue attrValue; + if (newAttr.getSchema().isUniqueConstraint()) { + attrValue = new JPACPlainAttrValue(); + ((PlainAttrUniqueValue) attrValue).setSchema(newAttr.getSchema()); + } else { + attrValue = new JPACPlainAttrValue(); + } + newAttr.add(value, attrValue); + } + @Test public void setAndDelete() { // 1. create CSChema - CPlainSchema useless = entityFactory.newEntity(CPlainSchema.class); + PlainSchema useless = entityFactory.newEntity(PlainSchema.class); useless.setKey("useless"); useless.setType(AttrSchemaType.Date); useless.setConversionPattern("yyyy-MM-dd"); @@ -72,7 +84,7 @@ public class ConfTest extends AbstractTest { // 2. create conf CPlainAttr newConf = entityFactory.newEntity(CPlainAttr.class); newConf.setSchema(useless); - newConf.addValue("2014-06-20", attrUtilsFactory.getInstance(AttributableType.CONFIGURATION)); + add(newConf, "2014-06-20"); confDAO.save(newConf); CPlainAttr actual = confDAO.find("useless"); @@ -80,7 +92,7 @@ public class ConfTest extends AbstractTest { // 3. update conf newConf.getValues().clear(); - newConf.addValue("2014-06-20", attrUtilsFactory.getInstance(AttributableType.CONFIGURATION)); + add(newConf, "2014-06-20"); confDAO.save(newConf); actual = confDAO.find("useless"); @@ -94,7 +106,7 @@ public class ConfTest extends AbstractTest { @Test public void issueSYNCOPE418() { try { - CPlainSchema failing = entityFactory.newEntity(CPlainSchema.class); + PlainSchema failing = entityFactory.newEntity(PlainSchema.class); failing.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); failing.setType(AttrSchemaType.String); plainSchemaDAO.save(failing); http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerAttrTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerAttrTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerAttrTest.java index 67765b1..11381e5 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerAttrTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerAttrTest.java @@ -27,21 +27,13 @@ import static org.junit.Assert.assertTrue; import java.util.List; 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.MembershipDAO; 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.membership.MDerAttr; -import org.apache.syncope.core.persistence.api.entity.membership.MDerAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.membership.MDerSchema; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.membership.Membership; +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.GDerAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.group.GDerSchema; 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.UDerSchema; 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; @@ -59,9 +51,6 @@ public class DerAttrTest extends AbstractTest { private UserDAO userDAO; @Autowired - private MembershipDAO membershipDAO; - - @Autowired private GroupDAO groupDAO; @Autowired @@ -81,7 +70,7 @@ public class DerAttrTest extends AbstractTest { @Test public void saveUDerAttribute() { - UDerSchema cnSchema = derSchemaDAO.find("cn", UDerSchema.class); + DerSchema cnSchema = derSchemaDAO.find("cn"); assertNotNull(cnSchema); User owner = userDAO.find(3L); @@ -104,38 +93,18 @@ public class DerAttrTest extends AbstractTest { } @Test - public void saveMDerAttribute() { - Membership owner = membershipDAO.find(1L); - assertNotNull("did not get expected user", owner); - - MDerAttr derAttr = entityFactory.newEntity(MDerAttr.class); - derAttr.setOwner(owner); - derAttr.setTemplate(owner.getGroup().getAttrTemplate(MDerAttrTemplate.class, "mderiveddata")); - - derAttr = derAttrDAO.save(derAttr); - assertNotNull(derAttr.getTemplate()); - - MDerAttr actual = derAttrDAO.find(derAttr.getKey(), MDerAttr.class); - assertNotNull("expected save to work", actual); - assertEquals(derAttr, actual); + public void saveGDerAttribute() { + DerSchema schema = derSchemaDAO.find("rderiveddata"); + assertNotNull(schema); - MPlainAttrValue sx = owner.getPlainAttr("mderived_sx").getValues().iterator().next(); - MPlainAttrValue dx = owner.getPlainAttr("mderived_dx").getValues().iterator().next(); - - assertEquals(sx.getValue() + "-" + dx.getValue(), derAttr.getValue(owner.getPlainAttrs())); - } - - @Test - public void saveRDerAttribute() { Group owner = groupDAO.find(1L); assertNotNull("did not get expected user", owner); GDerAttr derAttr = entityFactory.newEntity(GDerAttr.class); derAttr.setOwner(owner); - derAttr.setTemplate(owner.getAttrTemplate(GDerAttrTemplate.class, "rderiveddata")); + derAttr.setSchema(schema); derAttr = derAttrDAO.save(derAttr); - assertNotNull(derAttr.getTemplate()); GDerAttr actual = derAttrDAO.find(derAttr.getKey(), GDerAttr.class); assertNotNull("expected save to work", actual); @@ -150,27 +119,27 @@ public class DerAttrTest extends AbstractTest { @Test public void delete() { UDerAttr attribute = derAttrDAO.find(100L, UDerAttr.class); - String attributeSchemaName = attribute.getSchema().getKey(); + String schemaName = attribute.getSchema().getKey(); derAttrDAO.delete(attribute.getKey(), UDerAttr.class); UDerAttr actual = derAttrDAO.find(100L, UDerAttr.class); assertNull("delete did not work", actual); - UDerSchema attributeSchema = derSchemaDAO.find(attributeSchemaName, UDerSchema.class); - assertNotNull("user derived attribute schema deleted " + "when deleting values", attributeSchema); + DerSchema attributeSchema = derSchemaDAO.find(schemaName); + assertNotNull("user derived attribute schema deleted when deleting values", attributeSchema); } @Test public void issueSYNCOPE134User() { - UDerSchema sderived = entityFactory.newEntity(UDerSchema.class); + DerSchema sderived = entityFactory.newEntity(DerSchema.class); sderived.setKey("sderived"); sderived.setExpression("status + ' - ' + username + ' - ' + creationDate + '[' + failedLogins + ']'"); sderived = derSchemaDAO.save(sderived); derSchemaDAO.flush(); - UDerSchema actual = derSchemaDAO.find("sderived", UDerSchema.class); + DerSchema actual = derSchemaDAO.find("sderived"); assertNotNull("expected save to work", actual); assertEquals(sderived, actual); @@ -196,30 +165,25 @@ public class DerAttrTest extends AbstractTest { @Test public void issueSYNCOPE134Group() { - GDerSchema sderived = entityFactory.newEntity(GDerSchema.class); + DerSchema sderived = entityFactory.newEntity(DerSchema.class); sderived.setKey("sderived"); sderived.setExpression("name"); sderived = derSchemaDAO.save(sderived); derSchemaDAO.flush(); - GDerSchema actual = derSchemaDAO.find("sderived", GDerSchema.class); + DerSchema actual = derSchemaDAO.find("sderived"); assertNotNull("expected save to work", actual); assertEquals(sderived, actual); Group owner = groupDAO.find(7L); assertNotNull("did not get expected group", owner); - GDerAttrTemplate template = entityFactory.newEntity(GDerAttrTemplate.class); - template.setSchema(sderived); - owner.getAttrTemplates(GDerAttrTemplate.class).add(template); - GDerAttr derAttr = entityFactory.newEntity(GDerAttr.class); derAttr.setOwner(owner); - derAttr.setTemplate(owner.getAttrTemplate(GDerAttrTemplate.class, sderived.getKey())); + derAttr.setSchema(sderived); derAttr = derAttrDAO.save(derAttr); - assertNotNull(derAttr.getTemplate()); derAttrDAO.flush(); derAttr = derAttrDAO.find(derAttr.getKey(), GDerAttr.class); @@ -230,43 +194,4 @@ public class DerAttrTest extends AbstractTest { assertFalse(value.isEmpty()); assertTrue(value.startsWith("managingDirector")); } - - @Test - public void issueSYNCOPE134Memb() { - MDerSchema mderived = entityFactory.newEntity(MDerSchema.class); - mderived.setKey("mderived"); - mderived.setExpression("key"); - - mderived = derSchemaDAO.save(mderived); - derSchemaDAO.flush(); - - MDerSchema actual = derSchemaDAO.find("mderived", MDerSchema.class); - assertNotNull("expected save to work", actual); - assertEquals(mderived, actual); - - Membership owner = membershipDAO.find(4L); - assertNotNull("did not get expected membership", owner); - - MDerAttrTemplate template = entityFactory.newEntity(MDerAttrTemplate.class); - template.setSchema(mderived); - owner.getGroup().getAttrTemplates(MDerAttrTemplate.class).add(template); - - derSchemaDAO.flush(); - - MDerAttr derAttr = entityFactory.newEntity(MDerAttr.class); - derAttr.setOwner(owner); - derAttr.setTemplate(owner.getGroup().getAttrTemplate(MDerAttrTemplate.class, mderived.getKey())); - - derAttr = derAttrDAO.save(derAttr); - assertNotNull(derAttr.getTemplate()); - derAttrDAO.flush(); - - derAttr = derAttrDAO.find(derAttr.getKey(), MDerAttr.class); - assertNotNull("expected save to work", derAttr); - - String value = derAttr.getValue(owner.getPlainAttrs()); - assertNotNull(value); - assertFalse(value.isEmpty()); - assertTrue(value.equalsIgnoreCase("4")); - } } http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerSchemaTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerSchemaTest.java index 8b4090b..b123513 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerSchemaTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/DerSchemaTest.java @@ -25,13 +25,10 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.util.List; -import org.apache.syncope.common.lib.types.AttributableType; 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.api.entity.group.GDerSchema; -import org.apache.syncope.core.persistence.api.entity.user.UDerSchema; import org.apache.syncope.core.persistence.jpa.AbstractTest; import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -45,52 +42,52 @@ public class DerSchemaTest extends AbstractTest { @Test public void findAll() { - List<UDerSchema> list = derSchemaDAO.findAll(UDerSchema.class); - assertEquals(3, list.size()); + List<DerSchema> list = derSchemaDAO.findAll(); + assertEquals(9, list.size()); } @Test public void findByName() { - UDerSchema attributeSchema = derSchemaDAO.find("cn", UDerSchema.class); + DerSchema attributeSchema = derSchemaDAO.find("cn"); assertNotNull("did not find expected derived attribute schema", attributeSchema); } @Test public void save() { - UDerSchema derivedAttributeSchema = entityFactory.newEntity(UDerSchema.class); + DerSchema derivedAttributeSchema = entityFactory.newEntity(DerSchema.class); derivedAttributeSchema.setKey("cn2"); derivedAttributeSchema.setExpression("firstname surname"); derSchemaDAO.save(derivedAttributeSchema); - UDerSchema actual = derSchemaDAO.find("cn2", UDerSchema.class); + DerSchema actual = derSchemaDAO.find("cn2"); assertNotNull("expected save to work", actual); assertEquals(derivedAttributeSchema, actual); } @Test public void delete() { - UDerSchema cn = derSchemaDAO.find("cn", UDerSchema.class); + DerSchema cn = derSchemaDAO.find("cn"); assertNotNull(cn); - derSchemaDAO.delete(cn.getKey(), attrUtilsFactory.getInstance(AttributableType.USER)); + derSchemaDAO.delete(cn.getKey()); - DerSchema actual = derSchemaDAO.find("cn", UDerSchema.class); + DerSchema actual = derSchemaDAO.find("cn"); assertNull("delete did not work", actual); // ------------- // - GDerSchema rderiveddata = derSchemaDAO.find("rderiveddata", GDerSchema.class); + DerSchema rderiveddata = derSchemaDAO.find("rderiveddata"); assertNotNull(rderiveddata); - derSchemaDAO.delete(rderiveddata.getKey(), attrUtilsFactory.getInstance(AttributableType.GROUP)); + derSchemaDAO.delete(rderiveddata.getKey()); - actual = derSchemaDAO.find("rderiveddata", GDerSchema.class); + actual = derSchemaDAO.find("rderiveddata"); assertNull("delete did not work", actual); } @Test public void issueSYNCOPE418() { - UDerSchema schema = entityFactory.newEntity(UDerSchema.class); + DerSchema schema = entityFactory.newEntity(DerSchema.class); schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); try { http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/MembershipTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/MembershipTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/MembershipTest.java deleted file mode 100644 index a623b14..0000000 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/MembershipTest.java +++ /dev/null @@ -1,84 +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.entity; - -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.core.persistence.api.dao.MembershipDAO; -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.membership.Membership; -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 MembershipTest extends AbstractTest { - - @Autowired - private MembershipDAO membershipDAO; - - @Autowired - private UserDAO userDAO; - - @Autowired - private GroupDAO groupDAO; - - @Test - public void findAll() { - List<Membership> list = membershipDAO.findAll(); - assertEquals(7, list.size()); - } - - @Test - public void find() { - Membership membership = membershipDAO.find(1L); - assertNotNull("did not find expected membership", membership); - } - - @Test - public void save() { - User user = userDAO.find(4L); - Group group = groupDAO.find(1L); - - Membership membership = entityFactory.newEntity(Membership.class); - membership.setUser(user); - membership.setGroup(group); - - membership = membershipDAO.save(membership); - - Membership actual = membershipDAO.find(membership.getKey()); - assertNotNull("expected save to work", actual); - } - - @Test - public void delete() { - Membership membership = membershipDAO.find(4L); - membershipDAO.delete(membership.getKey()); - - Membership actual = membershipDAO.find(4L); - assertNull("delete did not work", actual); - } -} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/NotificationTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/NotificationTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/NotificationTest.java index 8b545b8..df629ff 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/NotificationTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/NotificationTest.java @@ -24,7 +24,9 @@ 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; @@ -35,6 +37,9 @@ import org.springframework.transaction.annotation.Transactional; public class NotificationTest extends AbstractTest { @Autowired + private AnyTypeDAO anyTypeDAO; + + @Autowired private NotificationDAO notificationDAO; @Test @@ -43,7 +48,7 @@ public class NotificationTest extends AbstractTest { assertNotNull(notification); assertNotNull(notification.getEvents()); assertFalse(notification.getEvents().isEmpty()); - assertNotNull(notification.getUserAbout()); + assertNotNull(notification.getAbout(anyTypeDAO.findUser())); assertNotNull(notification.getRecipients()); } @@ -60,9 +65,13 @@ public class NotificationTest extends AbstractTest { Notification notification = entityFactory.newEntity(Notification.class); notification.getEvents().add("save"); - notification.setUserAbout("fake search condition"); + 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.setRecipients("fake recipients"); notification.setRecipientAttrName("email"); notification.setRecipientAttrType(IntMappingType.UserPlainSchema); @@ -87,7 +96,11 @@ public class NotificationTest extends AbstractTest { Notification notification = entityFactory.newEntity(Notification.class); notification.getEvents().add("save"); - notification.setUserAbout("fake search condition"); + 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"); @@ -112,7 +125,11 @@ public class NotificationTest extends AbstractTest { Notification notification = entityFactory.newEntity(Notification.class); notification.getEvents().add("[REST]:[GroupLogic]:[]:[create]:[SUCCESS]"); - notification.setGroupAbout("fake search condition"); + 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); http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PlainSchemaTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PlainSchemaTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PlainSchemaTest.java index 27f587f..967a6be 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PlainSchemaTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PlainSchemaTest.java @@ -28,13 +28,11 @@ 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.AttributableType; 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.api.entity.group.GPlainSchema; -import org.apache.syncope.core.persistence.api.entity.user.UPlainSchema; import org.apache.syncope.core.persistence.jpa.AbstractTest; import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -48,35 +46,29 @@ public class PlainSchemaTest extends AbstractTest { @Test public void findAll() { - List<UPlainSchema> userList = plainSchemaDAO.findAll(UPlainSchema.class); - assertEquals(15, userList.size()); - - List<GPlainSchema> groupList = plainSchemaDAO.findAll(GPlainSchema.class); - assertEquals(5, groupList.size()); + List<PlainSchema> schemas = plainSchemaDAO.findAll(); + assertEquals(40, schemas.size()); } @Test public void findByName() { - UPlainSchema schema = plainSchemaDAO.find("fullname", UPlainSchema.class); + PlainSchema schema = plainSchemaDAO.find("fullname"); assertNotNull("did not find expected attribute schema", schema); } @Test public void findAttrs() { - List<GPlainSchema> schemas = plainSchemaDAO.findAll(GPlainSchema.class); - assertNotNull(schemas); - assertFalse(schemas.isEmpty()); - - for (GPlainSchema schema : schemas) { - List<GPlainAttr> attrs = plainSchemaDAO.findAttrs(schema, GPlainAttr.class); - assertNotNull(attrs); - assertFalse(attrs.isEmpty()); - } + PlainSchema schema = plainSchemaDAO.find("icon"); + assertNotNull(schema); + + List<GPlainAttr> attrs = plainSchemaDAO.findAttrs(schema, GPlainAttr.class); + assertNotNull(attrs); + assertFalse(attrs.isEmpty()); } @Test public void save() { - UPlainSchema schema = entityFactory.newEntity(UPlainSchema.class); + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); schema.setKey("secondaryEmail"); schema.setType(AttrSchemaType.String); schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator"); @@ -85,14 +77,14 @@ public class PlainSchemaTest extends AbstractTest { plainSchemaDAO.save(schema); - UPlainSchema actual = plainSchemaDAO.find("secondaryEmail", UPlainSchema.class); + PlainSchema actual = plainSchemaDAO.find("secondaryEmail"); assertNotNull("expected save to work", actual); assertEquals(schema, actual); } @Test(expected = InvalidEntityException.class) public void saveNonValid() { - UPlainSchema schema = entityFactory.newEntity(UPlainSchema.class); + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); schema.setKey("secondaryEmail"); schema.setType(AttrSchemaType.String); schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator"); @@ -105,7 +97,7 @@ public class PlainSchemaTest extends AbstractTest { @Test public void checkForEnumType() { - GPlainSchema schema = entityFactory.newEntity(GPlainSchema.class); + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); schema.setType(AttrSchemaType.Enum); schema.setKey("color"); @@ -122,7 +114,7 @@ public class PlainSchemaTest extends AbstractTest { plainSchemaDAO.save(schema); - GPlainSchema actual = plainSchemaDAO.find(schema.getKey(), GPlainSchema.class); + PlainSchema actual = plainSchemaDAO.find(schema.getKey()); assertNotNull(actual); assertNotNull(actual.getEnumerationKeys()); assertFalse(actual.getEnumerationKeys().isEmpty()); @@ -130,24 +122,24 @@ public class PlainSchemaTest extends AbstractTest { @Test(expected = InvalidEntityException.class) public void saveInvalidSchema() { - UPlainSchema schema = entityFactory.newEntity(UPlainSchema.class); + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); schema.setKey("username"); plainSchemaDAO.save(schema); } @Test public void delete() { - UPlainSchema fullnam = plainSchemaDAO.find("fullname", UPlainSchema.class); + PlainSchema firstname = plainSchemaDAO.find("firstname"); - plainSchemaDAO.delete(fullnam.getKey(), attrUtilsFactory.getInstance(AttributableType.USER)); + plainSchemaDAO.delete(firstname.getKey()); - UPlainSchema actual = plainSchemaDAO.find("fullname", UPlainSchema.class); + PlainSchema actual = plainSchemaDAO.find("firstname"); assertNull("delete did not work", actual); } @Test public void issueSYNCOPE418() { - UPlainSchema schema = entityFactory.newEntity(UPlainSchema.class); + PlainSchema schema = entityFactory.newEntity(PlainSchema.class); schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit";); try { http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java index 4267815..764f0ac 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java @@ -27,7 +27,9 @@ 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; @@ -40,6 +42,9 @@ import org.springframework.transaction.annotation.Transactional; public class PolicyTest extends AbstractTest { @Autowired + private AnyTypeDAO anyTypeDAO; + + @Autowired private PolicyDAO policyDAO; @Test @@ -80,11 +85,19 @@ public class PolicyTest extends AbstractTest { SyncPolicy policy = entityFactory.newEntity(SyncPolicy.class); final String syncURuleName = "net.tirasa.sync.correlation.TirasaURule"; - final String syncRRuleName = "net.tirasa.sync.correlation.TirasaRRule"; + final String syncGRuleName = "net.tirasa.sync.correlation.TirasaGRule"; SyncPolicySpec syncPolicySpec = new SyncPolicySpec(); - syncPolicySpec.setUserJavaRule(syncURuleName); - syncPolicySpec.setGroupJavaRule(syncRRuleName); + + 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"); @@ -93,8 +106,10 @@ public class PolicyTest extends AbstractTest { assertNotNull(policy); assertEquals(PolicyType.SYNC, policy.getType()); - assertEquals(syncURuleName, (policy.getSpecification(SyncPolicySpec.class)).getUserJavaRule()); - assertEquals(syncRRuleName, (policy.getSpecification(SyncPolicySpec.class)).getGroupJavaRule()); + assertEquals(syncURuleName, + (policy.getSpecification(SyncPolicySpec.class)).getItem(anyTypeDAO.findUser().getKey()).getJavaRule()); + assertEquals(syncGRuleName, + (policy.getSpecification(SyncPolicySpec.class)).getItem(anyTypeDAO.findGroup().getKey()).getJavaRule()); } @Test http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ResourceTest.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ResourceTest.java b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ResourceTest.java index a9340c3..ad6c37c 100644 --- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ResourceTest.java +++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/ResourceTest.java @@ -25,18 +25,21 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import java.util.ArrayList; import java.util.List; -import org.apache.syncope.common.lib.types.AttributableType; +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.ExternalResource; -import org.apache.syncope.core.persistence.api.entity.user.UMapping; -import org.apache.syncope.core.persistence.api.entity.user.UMappingItem; +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.junit.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -48,6 +51,9 @@ 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"); @@ -59,13 +65,16 @@ public class ResourceTest extends AbstractTest { "net.tirasa.connid.bundles.soap.WebServiceConnector", connector.getConnectorName()); assertEquals("invalid bundle name", "net.tirasa.connid.bundles.soap", connector.getBundleName()); - assertFalse("no mapping specified", resource.getUmapping().getItems().isEmpty()); + Mapping mapping = resource.getProvision(anyTypeDAO.findUser()).getMapping(); + assertFalse("no mapping specified", mapping.getItems().isEmpty()); - List<Long> mappingIds = new ArrayList<>(); - for (UMappingItem item : resource.getUmapping().getItems()) { - mappingIds.add(item.getKey()); - } - assertTrue(mappingIds.contains(100L)); + assertTrue(CollectionUtils.exists(mapping.getItems(), new Predicate<MappingItem>() { + + @Override + public boolean evaluate(final MappingItem item) { + return 100 == item.getKey(); + } + })); } @Test @@ -83,10 +92,11 @@ public class ResourceTest extends AbstractTest { } @Test - public void getAccountId() { + public void getConnObjectKey() { ExternalResource resource = resourceDAO.find("ws-target-resource-2"); assertNotNull(resource); - assertEquals("fullname", resource.getUmapping().getAccountIdItem().getIntAttrName()); + assertEquals("fullname", + resource.getProvision(anyTypeDAO.findUser()).getMapping().getConnObjectKeyItem().getIntAttrName()); } @Test @@ -96,15 +106,21 @@ public class ResourceTest extends AbstractTest { resource.setPropagationPriority(2); resource.setPropagationPrimary(true); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); + + Mapping mapping = entityFactory.newEntity(Mapping.class); + mapping.setProvision(provision); + provision.setMapping(mapping); - UMappingItem accountId = entityFactory.newEntity(UMappingItem.class); - accountId.setExtAttrName("username"); - accountId.setIntAttrName("fullname"); - accountId.setIntMappingType(IntMappingType.UserId); - accountId.setPurpose(MappingPurpose.BOTH); - mapping.setAccountIdItem(accountId); + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setExtAttrName("username"); + connObjectKey.setIntAttrName("fullname"); + connObjectKey.setIntMappingType(IntMappingType.UserId); + connObjectKey.setPurpose(MappingPurpose.BOTH); + mapping.setConnObjectKeyItem(connObjectKey); ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); resource.setConnector(connector); @@ -114,8 +130,8 @@ public class ResourceTest extends AbstractTest { assertNotNull(actual); assertNotNull(actual.getConnector()); - assertNotNull(actual.getUmapping()); - assertFalse(actual.getUmapping().getItems().isEmpty()); + assertNotNull(actual.getProvision(anyTypeDAO.findUser()).getMapping()); + assertFalse(actual.getProvision(anyTypeDAO.findUser()).getMapping().getItems().isEmpty()); assertEquals(Integer.valueOf(2), actual.getPropagationPriority()); assertTrue(actual.isPropagationPrimary()); } @@ -128,13 +144,19 @@ public class ResourceTest extends AbstractTest { ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); resource.setConnector(connector); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); - UMappingItem accountId = entityFactory.newEntity(UMappingItem.class); - accountId.setAccountid(true); - accountId.setIntMappingType(IntMappingType.UserPlainSchema); - mapping.addItem(accountId); + 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 ExternalResource actual = resourceDAO.save(resource); @@ -142,20 +164,26 @@ public class ResourceTest extends AbstractTest { } @Test(expected = IllegalArgumentException.class) - public void saveInvalidAccountIdMapping() { + 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); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); + + Mapping mapping = entityFactory.newEntity(Mapping.class); + mapping.setProvision(provision); + provision.setMapping(mapping); - UMappingItem accountId = entityFactory.newEntity(UMappingItem.class); - accountId.setAccountid(true); - accountId.setIntMappingType(IntMappingType.UserVirtualSchema); - mapping.setAccountIdItem(accountId); + MappingItem connObjectKey = entityFactory.newEntity(MappingItem.class); + connObjectKey.setConnObjectKey(true); + connObjectKey.setIntMappingType(IntMappingType.UserVirtualSchema); + mapping.setConnObjectKeyItem(connObjectKey); // save the resource ExternalResource actual = resourceDAO.save(resource); @@ -170,19 +198,25 @@ public class ResourceTest extends AbstractTest { ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); resource.setConnector(connector); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); + + Mapping mapping = entityFactory.newEntity(Mapping.class); + mapping.setProvision(provision); + provision.setMapping(mapping); - UMappingItem item = entityFactory.newEntity(UMappingItem.class); - item.setAccountid(true); + MappingItem item = entityFactory.newEntity(MappingItem.class); + item.setConnObjectKey(true); item.setIntAttrName("fullname"); item.setIntMappingType(IntMappingType.UserPlainSchema); - mapping.addItem(item); + mapping.add(item); - item = entityFactory.newEntity(UMappingItem.class); + item = entityFactory.newEntity(MappingItem.class); item.setIntAttrName("userId"); item.setIntMappingType(IntMappingType.UserPlainSchema); - mapping.addItem(item); + mapping.add(item); ExternalResource actual = resourceDAO.save(resource); assertNotNull(actual); @@ -196,45 +230,49 @@ public class ResourceTest extends AbstractTest { ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); resource.setConnector(connector); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); - UMappingItem item = entityFactory.newEntity(UMappingItem.class); + 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.setAccountIdItem(item); + mapping.setConnObjectKeyItem(item); - item = entityFactory.newEntity(UMappingItem.class); + item = entityFactory.newEntity(MappingItem.class); item.setIntAttrName("icon"); item.setExtAttrName("icon"); item.setIntMappingType(IntMappingType.GroupPlainSchema); item.setPurpose(MappingPurpose.BOTH); - mapping.addItem(item); + mapping.add(item); - item = entityFactory.newEntity(UMappingItem.class); + item = entityFactory.newEntity(MappingItem.class); item.setIntAttrName("mderiveddata"); item.setExtAttrName("mderiveddata"); - item.setIntMappingType(IntMappingType.MembershipDerivedSchema); + item.setIntMappingType(IntMappingType.AnyDerivedSchema); item.setPurpose(MappingPurpose.BOTH); - mapping.addItem(item); + mapping.add(item); // save the resource ExternalResource actual = resourceDAO.save(resource); assertNotNull(actual); int items = 0; - for (UMappingItem mapItem : actual.getUmapping().getItems()) { + for (MappingItem mapItem : actual.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) { items++; if ("icon".equals(mapItem.getIntAttrName())) { - assertTrue(IntMappingType.contains(AttributableType.GROUP, - mapItem.getIntMappingType().toString())); + assertTrue(IntMappingType.contains(AnyTypeKind.GROUP, mapItem.getIntMappingType().toString())); } if ("mderiveddata".equals(mapItem.getIntAttrName())) { - assertTrue(IntMappingType.contains(AttributableType.MEMBERSHIP, - mapItem.getIntMappingType().toString())); + assertTrue(IntMappingType.contains(AnyTypeKind.ANY_OBJECT, mapItem.getIntMappingType().toString())); } } assertEquals(3, items); @@ -272,15 +310,21 @@ public class ResourceTest extends AbstractTest { ConnInstance connector = resourceDAO.find("ws-target-resource-1").getConnector(); resource.setConnector(connector); - UMapping mapping = entityFactory.newEntity(UMapping.class); - resource.setUmapping(mapping); + Provision provision = entityFactory.newEntity(Provision.class); + provision.setAnyType(anyTypeDAO.findUser()); + provision.setResource(resource); + resource.add(provision); + + Mapping mapping = entityFactory.newEntity(Mapping.class); + mapping.setProvision(provision); + provision.setMapping(mapping); - final UMappingItem item = entityFactory.newEntity(UMappingItem.class); + final MappingItem item = entityFactory.newEntity(MappingItem.class); item.setIntAttrName("icon"); item.setExtAttrName("icon"); item.setIntMappingType(IntMappingType.GroupPlainSchema); item.setPurpose(MappingPurpose.BOTH); - mapping.setAccountIdItem(item); + mapping.setConnObjectKeyItem(item); // save the resource ExternalResource actual = resourceDAO.save(resource);
