You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@syncope.apache.org by il...@apache.org on 2015/05/25 16:50:48 UTC
[12/29] syncope git commit: [SYNCOPE-666] Initial commit,
Travis CI builds disabled
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("john.doe@gmail.com", attrUtilsFactory.getInstance(AttributableType.USER));
- attribute.addValue("mario.rossi@gmail.com", attrUtilsFactory.getInstance(AttributableType.USER));
+ attribute.add("john.doe@gmail.com", anyUtilsFactory.getInstance(AnyTypeKind.USER));
+ attribute.add("mario.rossi@gmail.com", 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);