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/04/21 11:34:24 UTC
[55/57] syncope git commit: [SYNCOPE-119] Merge from master
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java
----------------------------------------------------------------------
diff --cc core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java
index a635207,0000000..2fe1ae9
mode 100644,000000..100644
--- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java
+++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java
@@@ -1,879 -1,0 +1,862 @@@
+/*
+ * 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 java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.apache.syncope.common.lib.to.AbstractAttributableTO;
+import org.apache.syncope.common.lib.to.AbstractSubjectTO;
+import org.apache.syncope.common.lib.to.ConfTO;
+import org.apache.syncope.common.lib.to.MembershipTO;
+import org.apache.syncope.common.lib.to.GroupTO;
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.common.lib.types.AttributableType;
+import org.apache.syncope.common.lib.types.IntMappingType;
+import org.apache.syncope.common.lib.types.MappingPurpose;
+import org.apache.syncope.core.persistence.api.entity.AttrTemplate;
+import org.apache.syncope.core.persistence.api.entity.Attributable;
+import org.apache.syncope.core.persistence.api.entity.AttributableUtils;
+import org.apache.syncope.core.persistence.api.entity.DerAttr;
+import org.apache.syncope.core.persistence.api.entity.DerSchema;
+import org.apache.syncope.core.persistence.api.entity.ExternalResource;
+import org.apache.syncope.core.persistence.api.entity.MappingItem;
+import org.apache.syncope.core.persistence.api.entity.PlainAttr;
+import org.apache.syncope.core.persistence.api.entity.PlainAttrValue;
+import org.apache.syncope.core.persistence.api.entity.PlainSchema;
+import org.apache.syncope.core.persistence.api.entity.VirAttr;
+import org.apache.syncope.core.persistence.api.entity.VirSchema;
+import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttr;
+import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrUniqueValue;
+import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrValue;
+import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainSchema;
+import org.apache.syncope.core.persistence.jpa.entity.conf.JPAConf;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttr;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerSchema;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttr;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrUniqueValue;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrValue;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainSchema;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttr;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirSchema;
+import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMembership;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttr;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerSchema;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGMappingItem;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttr;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrUniqueValue;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrValue;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainSchema;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttr;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttrTemplate;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirSchema;
+import org.apache.syncope.core.persistence.jpa.entity.group.JPAGroup;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerAttr;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerSchema;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMappingItem;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttr;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrUniqueValue;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrValue;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainSchema;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirAttr;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirSchema;
+import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser;
- import org.apache.syncope.core.misc.spring.BeanUtils;
- import org.identityconnectors.framework.common.objects.Uid;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({ "unchecked", "rawtypes" })
+public class JPAAttributableUtils implements AttributableUtils {
+
+ /**
+ * Logger.
+ */
+ private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(AttributableUtils.class);
+
+ private final AttributableType type;
+
+ protected JPAAttributableUtils(final AttributableType type) {
+ this.type = type;
+ }
+
+ @Override
+ public AttributableType getType() {
+ return type;
+ }
+
+ @Override
+ public <T extends Attributable<?, ?, ?>> Class<T> attributableClass() {
+ Class result;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGroup.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMembership.class;
+ break;
+
+ case CONFIGURATION:
+ result = JPAConf.class;
+ break;
+
+ case USER:
+ default:
+ result = JPAUser.class;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainSchema> Class<T> plainSchemaClass() {
+ Class result;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGPlainSchema.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMPlainSchema.class;
+ break;
+
+ case CONFIGURATION:
+ result = JPACPlainSchema.class;
+ break;
+
+ case USER:
+ default:
+ result = JPAUPlainSchema.class;
+ break;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainSchema> T newPlainSchema() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUPlainSchema();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGPlainSchema();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMPlainSchema();
+ break;
+
+ case CONFIGURATION:
+ result = (T) new JPACPlainSchema();
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttr> Class<T> plainAttrClass() {
+ Class result = null;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGPlainAttr.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMPlainAttr.class;
+ break;
+
+ case CONFIGURATION:
+ result = JPACPlainAttr.class;
+ break;
+
+ case USER:
+ default:
+ result = JPAUPlainAttr.class;
+ break;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttr> T newPlainAttr() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUPlainAttr();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGPlainAttr();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMPlainAttr();
+ break;
+
+ case CONFIGURATION:
+ result = (T) new JPACPlainAttr();
+
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttrValue> Class<T> plainAttrValueClass() {
+ Class result;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGPlainAttrValue.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMPlainAttrValue.class;
+ break;
+
+ case CONFIGURATION:
+ result = JPACPlainAttrValue.class;
+ break;
+
+ case USER:
+ default:
+ result = JPAUPlainAttrValue.class;
+ break;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttrValue> T newPlainAttrValue() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUPlainAttrValue();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGPlainAttrValue();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMPlainAttrValue();
+ break;
+
+ case CONFIGURATION:
+ result = (T) new JPACPlainAttrValue();
+ break;
+
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttrValue> Class<T> plainAttrUniqueValueClass() {
+ Class result;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGPlainAttrUniqueValue.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMPlainAttrUniqueValue.class;
+ break;
+
+ case CONFIGURATION:
+ result = JPACPlainAttrUniqueValue.class;
+ break;
+
+ case USER:
+ default:
+ result = JPAUPlainAttrUniqueValue.class;
+ break;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends PlainAttrValue> T newPlainAttrUniqueValue() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUPlainAttrUniqueValue();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGPlainAttrUniqueValue();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMPlainAttrUniqueValue();
+ break;
+
+ case CONFIGURATION:
+ result = (T) new JPACPlainAttrUniqueValue();
+ break;
+
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends AttrTemplate<PlainSchema>> Class<T> plainAttrTemplateClass() {
+ Class result;
+
+ switch (type) {
+ case GROUP:
+ result = JPAGPlainAttrTemplate.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMPlainAttrTemplate.class;
+ break;
+
+ case USER:
+ case CONFIGURATION:
+ default:
+ result = null;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends DerSchema> Class<T> derSchemaClass() {
+ Class result;
+
+ switch (type) {
+ case USER:
+ result = JPAUDerSchema.class;
+ break;
+
+ case GROUP:
+ result = JPAGDerSchema.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMDerSchema.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ result = null;
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends DerSchema> T newDerSchema() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUDerSchema();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGDerSchema();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMDerSchema();
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends DerAttr> Class<T> derAttrClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ result = JPAUDerAttr.class;
+ break;
+
+ case GROUP:
+ result = JPAGDerAttr.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMDerAttr.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends DerAttr> T newDerAttr() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUDerAttr();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGDerAttr();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMDerAttr();
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends AttrTemplate<DerSchema>> Class<T> derAttrTemplateClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ break;
+
+ case GROUP:
+ result = JPAGDerAttrTemplate.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMDerAttrTemplate.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends VirSchema> Class<T> virSchemaClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ result = JPAUVirSchema.class;
+ break;
+
+ case GROUP:
+ result = JPAGVirSchema.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMVirSchema.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends VirSchema> T newVirSchema() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUVirSchema();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGVirSchema();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMVirSchema();
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends VirAttr> Class<T> virAttrClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ result = JPAUVirAttr.class;
+ break;
+
+ case GROUP:
+ result = JPAGVirAttr.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMVirAttr.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends VirAttr> T newVirAttr() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new JPAUVirAttr();
+ break;
+
+ case GROUP:
+ result = (T) new JPAGVirAttr();
+ break;
+
+ case MEMBERSHIP:
+ result = (T) new JPAMVirAttr();
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends AttrTemplate<VirSchema>> Class<T> virAttrTemplateClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ break;
+
+ case GROUP:
+ result = JPAGVirAttrTemplate.class;
+ break;
+
+ case MEMBERSHIP:
+ result = JPAMVirAttrTemplate.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends MappingItem> T getAccountIdItem(final ExternalResource resource) {
+ T result = null;
+
+ if (resource != null) {
+ switch (type) {
+ case GROUP:
+ if (resource.getGmapping() != null) {
+ result = (T) resource.getGmapping().getAccountIdItem();
+ }
+ break;
+
+ case MEMBERSHIP:
+ case USER:
+ if (resource.getUmapping() != null) {
+ result = (T) resource.getUmapping().getAccountIdItem();
+ }
+ break;
+
+ default:
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public String getAccountLink(final ExternalResource resource) {
+ String result = null;
+
+ if (resource != null) {
+ switch (type) {
+ case USER:
+ if (resource.getUmapping() != null) {
+ result = resource.getUmapping().getAccountLink();
+ }
+ break;
+
+ case GROUP:
+ if (resource.getGmapping() != null) {
+ result = resource.getGmapping().getAccountLink();
+ }
+ break;
+
+ case MEMBERSHIP:
+ case CONFIGURATION:
+ default:
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends MappingItem> List<T> getMappingItems(
+ final ExternalResource resource, final MappingPurpose purpose) {
+
+ List<T> items = Collections.<T>emptyList();
+
+ if (resource != null) {
+ switch (type) {
+ case GROUP:
+ if (resource.getGmapping() != null) {
+ items = (List<T>) resource.getGmapping().getItems();
+ }
+ break;
+
+ case MEMBERSHIP:
+ case USER:
+ if (resource.getUmapping() != null) {
+ items = (List<T>) resource.getUmapping().getItems();
+ }
+ break;
+
+ default:
+ }
+ }
+
+ final List<T> result = new ArrayList<>();
+
+ switch (purpose) {
+ case SYNCHRONIZATION:
+ for (T item : items) {
+ if (MappingPurpose.PROPAGATION != item.getPurpose()
+ && MappingPurpose.NONE != item.getPurpose()) {
+
+ result.add(item);
+ }
+ }
+ break;
+
+ case PROPAGATION:
+ for (T item : items) {
+ if (MappingPurpose.SYNCHRONIZATION != item.getPurpose()
+ && MappingPurpose.NONE != item.getPurpose()) {
+
+ result.add(item);
+ }
+ }
+ break;
+
+ case BOTH:
+ for (T item : items) {
+ if (MappingPurpose.NONE != item.getPurpose()) {
+ result.add(item);
+ }
+ }
+ break;
+
+ case NONE:
+ for (T item : items) {
+ if (MappingPurpose.NONE == item.getPurpose()) {
+ result.add(item);
+ }
+ }
+ break;
+ default:
+ LOG.error("You requested not existing purpose {}", purpose);
+ }
+
+ return result;
+ }
+
+ @Override
- public <T extends MappingItem> List<T> getUidToMappingItems(
- final ExternalResource resource, final MappingPurpose purpose) {
-
- List<T> items = getMappingItems(resource, purpose);
-
- MappingItem uidItem = type == AttributableType.USER ? new JPAUMappingItem() : new JPAGMappingItem();
- BeanUtils.copyProperties(getAccountIdItem(resource), uidItem);
- uidItem.setExtAttrName(Uid.NAME);
- uidItem.setAccountid(false);
- items.add((T) uidItem);
-
- return items;
- }
-
- @Override
+ public IntMappingType plainIntMappingType() {
+ IntMappingType result = null;
+
+ switch (type) {
+ case GROUP:
+ result = IntMappingType.GroupPlainSchema;
+ break;
+
+ case MEMBERSHIP:
+ result = IntMappingType.MembershipPlainSchema;
+ break;
+
+ case USER:
+ result = IntMappingType.UserPlainSchema;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public IntMappingType derIntMappingType() {
+ IntMappingType result = null;
+
+ switch (type) {
+ case GROUP:
+ result = IntMappingType.GroupDerivedSchema;
+ break;
+
+ case MEMBERSHIP:
+ result = IntMappingType.MembershipDerivedSchema;
+ break;
+
+ case USER:
+ result = IntMappingType.UserDerivedSchema;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public IntMappingType virIntMappingType() {
+ IntMappingType result = null;
+
+ switch (type) {
+ case GROUP:
+ result = IntMappingType.GroupVirtualSchema;
+ break;
+
+ case MEMBERSHIP:
+ result = IntMappingType.MembershipVirtualSchema;
+ break;
+
+ case USER:
+ result = IntMappingType.UserVirtualSchema;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends MappingItem> Class<T> mappingItemClass() {
+ Class result = null;
+
+ switch (type) {
+ case USER:
+ result = JPAUMappingItem.class;
+ break;
+
+ case GROUP:
+ result = JPAGMappingItem.class;
+ break;
+
+ case MEMBERSHIP:
+ result = AbstractMappingItem.class;
+ break;
+
+ case CONFIGURATION:
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends AbstractAttributableTO> T newAttributableTO() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new UserTO();
+ break;
+ case GROUP:
+ result = (T) new GroupTO();
+ break;
+ case MEMBERSHIP:
+ result = (T) new MembershipTO();
+ break;
+ case CONFIGURATION:
+ result = (T) new ConfTO();
+ break;
+ default:
+ }
+
+ return result;
+ }
+
+ @Override
+ public <T extends AbstractSubjectTO> T newSubjectTO() {
+ T result = null;
+
+ switch (type) {
+ case USER:
+ result = (T) new UserTO();
+ break;
+ case GROUP:
+ result = (T) new GroupTO();
+ break;
+ case MEMBERSHIP:
+ case CONFIGURATION:
+ default:
+ break;
+ }
+
+ return result;
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java
----------------------------------------------------------------------
diff --cc core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/PolicyTest.java
index 2d8a85b,304fde0..4267815
--- 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
@@@ -29,7 -29,7 +29,6 @@@ import org.apache.syncope.common.lib.ty
import org.apache.syncope.common.lib.types.SyncPolicySpec;
import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException;
import org.apache.syncope.core.persistence.api.dao.PolicyDAO;
--import org.apache.syncope.core.persistence.api.entity.PasswordPolicy;
import org.apache.syncope.core.persistence.api.entity.Policy;
import org.apache.syncope.core.persistence.api.entity.SyncPolicy;
import org.apache.syncope.core.persistence.jpa.AbstractTest;
@@@ -76,22 -86,22 +75,9 @@@ public class PolicyTest extends Abstrac
policyDAO.save(policy);
}
-- @Test(expected = InvalidEntityException.class)
-- public void saveSecondPasswordPolicy() {
-- PasswordPolicySpec passwordPolicy = new PasswordPolicySpec();
-- passwordPolicy.setMaxLength(8);
-- passwordPolicy.setMinLength(6);
--
- PasswordPolicy policy = entityFactory.newEntity(PasswordPolicy.class);
- PasswordPolicy policy = entityFactory.newPolicy(PasswordPolicy.class, true);
-- policy.setSpecification(passwordPolicy);
-- policy.setDescription("global password policy");
--
-- policyDAO.save(policy);
-- }
--
@Test
public void create() {
- SyncPolicy policy = entityFactory.newPolicy(SyncPolicy.class, false);
+ SyncPolicy policy = entityFactory.newEntity(SyncPolicy.class);
final String syncURuleName = "net.tirasa.sync.correlation.TirasaURule";
final String syncRRuleName = "net.tirasa.sync.correlation.TirasaRRule";
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/RealmTest.java
----------------------------------------------------------------------
diff --cc core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/RealmTest.java
index 811d808,0000000..e5e55fe
mode 100644,000000..100644
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/RealmTest.java
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/RealmTest.java
@@@ -1,178 -1,0 +1,178 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.syncope.core.persistence.jpa.entity;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.syncope.common.lib.SyncopeConstants;
+import org.apache.syncope.common.lib.types.EntityViolationType;
+import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException;
+import org.apache.syncope.core.persistence.api.dao.MalformedPathException;
+import org.apache.syncope.core.persistence.api.dao.PolicyDAO;
+import org.apache.syncope.core.persistence.api.dao.RealmDAO;
+import org.apache.syncope.core.persistence.api.entity.AccountPolicy;
+import org.apache.syncope.core.persistence.api.entity.PasswordPolicy;
+import org.apache.syncope.core.persistence.api.entity.Realm;
+import org.apache.syncope.core.persistence.jpa.AbstractTest;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class RealmTest extends AbstractTest {
+
+ @Autowired
+ private RealmDAO realmDAO;
+
+ @Autowired
+ private PolicyDAO policyDAO;
+
+ @Test
+ public void getRoot() {
+ assertNotNull(realmDAO.getRoot());
+ }
+
+ @Test
+ public void find() {
+ Realm realm = realmDAO.find(1L);
+ assertNotNull(realm);
+ assertEquals(SyncopeConstants.ROOT_REALM, realm.getName());
+ assertEquals(SyncopeConstants.ROOT_REALM, realm.getFullPath());
+
+ realm = realmDAO.find(3L);
+ assertNotNull(realm);
+ assertEquals("even", realm.getName());
+ assertEquals("/even", realm.getFullPath());
+ assertEquals(1, realm.getParent().getKey(), 0);
+ assertEquals(realmDAO.getRoot(), realm.getParent());
+
+ realm = realmDAO.find("/even/two");
+ assertNotNull(realm);
+ assertEquals(4, realm.getKey(), 0);
+ assertEquals("two", realm.getName());
+ assertEquals("/even/two", realm.getFullPath());
+ }
+
+ @Test(expected = MalformedPathException.class)
+ public void findInvalidPath() {
+ realmDAO.find("even/two");
+ }
+
+ @Test
+ public void findChildren() {
+ List<Realm> children = realmDAO.findChildren(realmDAO.find(SyncopeConstants.ROOT_REALM));
+ assertEquals(2, children.size());
+ assertTrue(children.contains(realmDAO.find("/odd")));
+ assertTrue(children.contains(realmDAO.find("/even")));
+
+ children = realmDAO.findChildren(realmDAO.find("/odd"));
+ assertTrue(children.isEmpty());
+ }
+
+ @Test
+ public void findDescendants() {
+ assertTrue(CollectionUtils.disjunction(realmDAO.findAll(), realmDAO.findDescendants(realmDAO.getRoot())).
+ isEmpty());
+ }
+
+ @Test
+ public void findAll() {
+ List<Realm> list = realmDAO.findAll();
+ assertNotNull(list);
+ assertFalse(list.isEmpty());
+ for (Realm realm : list) {
+ assertNotNull(realm);
+ }
+ }
+
+ @Test
+ public void save() {
+ Realm realm = entityFactory.newEntity(Realm.class);
+ realm.setName("last");
+ realm.setParent(realmDAO.find("/even/two"));
+ assertNull(realm.getKey());
+
+ Realm actual = realmDAO.save(realm);
+ assertNotNull(actual.getKey());
+ assertEquals("last", actual.getName());
+ assertEquals("/even/two/last", actual.getFullPath());
+ assertEquals(realmDAO.find("/even/two"), actual.getParent());
- assertNull(realm.getAccountPolicy());
- assertNull(realm.getPasswordPolicy());
++ assertEquals(5L, realm.getAccountPolicy().getKey(), 0);
++ assertEquals(2L, realm.getPasswordPolicy().getKey(), 0);
+
+ realm = actual;
+ realm.setAccountPolicy((AccountPolicy) policyDAO.find(6L));
+ realm.setPasswordPolicy((PasswordPolicy) policyDAO.find(4L));
+
+ actual = realmDAO.save(realm);
- assertNotNull(actual.getAccountPolicy());
- assertNotNull(actual.getPasswordPolicy());
++ assertEquals(6L, actual.getAccountPolicy().getKey(), 0);
++ assertEquals(4L, actual.getPasswordPolicy().getKey(), 0);
+ }
+
+ @Test
+ public void saveInvalidName() {
+ Realm realm = entityFactory.newEntity(Realm.class);
+ realm.setName(" a name");
+ realm.setParent(realmDAO.getRoot());
+
+ try {
+ realmDAO.save(realm);
+ fail();
+ } catch (InvalidEntityException e) {
+ assertTrue(e.hasViolation(EntityViolationType.InvalidRealm));
+ }
+ }
+
+ @Test
+ public void saveNullParent() {
+ Realm realm = entityFactory.newEntity(Realm.class);
+ realm.setName("name");
+ realm.setParent(null);
+
+ try {
+ realmDAO.save(realm);
+ fail();
+ } catch (InvalidEntityException e) {
+ assertTrue(e.hasViolation(EntityViolationType.InvalidRealm));
+ }
+ }
+
+ @Test
+ public void delete() {
+ Realm realm = entityFactory.newEntity(Realm.class);
+ realm.setName("name");
+ realm.setParent(realmDAO.getRoot());
+
+ Realm actual = realmDAO.save(realm);
+ assertNotNull(actual);
+
+ Long key = actual.getKey();
+ assertNotNull(realmDAO.find(key));
+
+ realmDAO.delete(key);
+ assertNull(realmDAO.find(key));
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/UserTest.java
----------------------------------------------------------------------
diff --cc core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/UserTest.java
index 29fbc4c,38be1ac..d606dac
--- a/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/UserTest.java
+++ b/core/persistence-jpa/src/test/java/org/apache/syncope/core/persistence/jpa/entity/UserTest.java
@@@ -185,10 -189,9 +185,10 @@@ public class UserTest extends AbstractT
public void issue237() {
User user = entityFactory.newEntity(User.class);
user.setUsername("username");
+ user.setRealm(realmDAO.find("/even/two"));
user.setCreationDate(new Date());
-- user.setPassword("password", CipherAlgorithm.AES);
++ user.setPassword("password123", CipherAlgorithm.AES);
User actual = userDAO.save(user);
assertNotNull(actual);
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/core/rest-cxf/src/main/java/org/apache/syncope/core/rest/cxf/RestServiceExceptionMapper.java
----------------------------------------------------------------------
diff --cc core/rest-cxf/src/main/java/org/apache/syncope/core/rest/cxf/RestServiceExceptionMapper.java
index ab71890,c10481f..92b93a2
--- a/core/rest-cxf/src/main/java/org/apache/syncope/core/rest/cxf/RestServiceExceptionMapper.java
+++ b/core/rest-cxf/src/main/java/org/apache/syncope/core/rest/cxf/RestServiceExceptionMapper.java
@@@ -50,9 -52,12 +53,13 @@@ import org.apache.syncope.core.persiste
import org.apache.syncope.core.persistence.api.dao.NotFoundException;
import org.apache.syncope.core.workflow.api.WorkflowException;
import org.identityconnectors.framework.common.exceptions.ConfigurationException;
+import org.identityconnectors.framework.common.exceptions.ConnectorException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+ import org.springframework.beans.factory.annotation.Autowired;
+ import org.springframework.context.annotation.Configuration;
+ import org.springframework.context.annotation.PropertySource;
+ import org.springframework.core.env.Environment;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.orm.jpa.JpaSystemException;
import org.springframework.security.access.AccessDeniedException;
@@@ -67,6 -74,17 +76,19 @@@ public class RestServiceExceptionMappe
private final ValidationExceptionMapper validationEM = new ValidationExceptionMapper();
+ @Autowired
+ private Environment env;
+
- private static final Map<String, String> exceptionCodeMap;
++ private static final Map<String, String> EXCEPTION_CODE_MAP = new HashMap<String, String>() {
+
- static {
- exceptionCodeMap = new HashMap<>();
- exceptionCodeMap.put("23000", "UniqueConstraintViolation");
- exceptionCodeMap.put("23505", "UniqueConstraintViolation");
- }
++ private static final long serialVersionUID = -7688359318035249200L;
++
++ {
++ put("23000", "UniqueConstraintViolation");
++ put("23505", "UniqueConstraintViolation");
++ }
++ };
+
@Override
public Response toResponse(final Exception ex) {
LOG.error("Exception thrown by REST method: " + ex.getMessage(), ex);
@@@ -90,14 -108,12 +112,14 @@@
} else if (ex instanceof AccessDeniedException) {
builder = Response.status(Response.Status.UNAUTHORIZED).
header(HttpHeaders.WWW_AUTHENTICATE, BASIC_REALM_UNAUTHORIZED);
- } else if (ex instanceof UnauthorizedRoleException) {
- builder = builder(Response.Status.UNAUTHORIZED, ClientExceptionType.UnauthorizedRole, getExMessage(ex));
+ } else if (ex instanceof UnauthorizedException) {
+ builder = builder(ClientExceptionType.Unauthorized, getExMessage(ex));
} else if (ex instanceof EntityExistsException || ex instanceof DuplicateException) {
- builder = builder(ClientExceptionType.EntityExists, getExMessage(ex));
- } else if (ex instanceof DataIntegrityViolationException) {
- builder = builder(ClientExceptionType.DataIntegrityViolation, getExMessage(ex));
- builder = builder(Response.Status.CONFLICT, ClientExceptionType.EntityExists, getJPAMessage(ex));
++ builder = builder(ClientExceptionType.EntityExists, getJPAMessage(ex));
+ } else if (ex instanceof DataIntegrityViolationException || ex instanceof JpaSystemException) {
- builder = builder(Response.Status.CONFLICT, ClientExceptionType.DataIntegrityViolation, getJPAMessage(ex));
++ builder = builder(ClientExceptionType.DataIntegrityViolation, getJPAMessage(ex));
+ } else if (ex instanceof ConnectorException) {
- builder = builder(ClientExceptionType.ConnectorException, getExMessage(ex));
++ builder = builder(ClientExceptionType.ConnectorException, getExMessage(ex));
} else {
builder = processNotFoundExceptions(ex);
if (builder == null) {
@@@ -288,4 -301,18 +309,18 @@@
private String getExMessage(final Throwable ex) {
return (ex.getCause() == null) ? ex.getMessage() : ex.getCause().getMessage();
}
+
+ private String getJPAMessage(final Throwable ex) {
+ Throwable throwable = ExceptionUtils.getRootCause(ex);
+ String message = null;
+ if (throwable instanceof SQLException) {
+ String SQLState = ((SQLException) throwable).getSQLState();
- String messageKey = exceptionCodeMap.get(SQLState);
++ String messageKey = EXCEPTION_CODE_MAP.get(SQLState);
+ if (messageKey != null) {
+ message = env.getProperty("errMessage." + messageKey);
+ }
+ }
+
+ return message == null ? getExMessage(ex) : message;
+ }
}
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ConnectorITCase.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ExceptionMapperITCase.java
----------------------------------------------------------------------
diff --cc fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ExceptionMapperITCase.java
index 0000000,3b48ad6..6a42f5a
mode 000000,100644..100644
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ExceptionMapperITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/ExceptionMapperITCase.java
@@@ -1,0 -1,139 +1,143 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+ package org.apache.syncope.fit.core.reference;
+
+ import static org.junit.Assert.assertEquals;
+ import static org.junit.Assert.fail;
+
+ import java.io.IOException;
+ import java.io.InputStream;
+ import java.util.Properties;
+ import org.apache.commons.io.IOUtils;
+ import org.apache.syncope.common.lib.SyncopeClientCompositeException;
++import org.apache.syncope.common.lib.SyncopeConstants;
+ import org.apache.syncope.common.lib.to.PlainSchemaTO;
+ import org.apache.syncope.common.lib.to.RoleTO;
+ import org.apache.syncope.common.lib.to.UserTO;
+ import org.apache.syncope.common.lib.types.AttrSchemaType;
+ import org.apache.syncope.common.lib.types.AttributableType;
+ import org.apache.syncope.common.lib.types.SchemaType;
-import org.junit.Assert;
+ import org.junit.BeforeClass;
+ import org.junit.FixMethodOrder;
+ import org.junit.Test;
+ import org.junit.runners.MethodSorters;
+
+ @FixMethodOrder(MethodSorters.JVM)
+ public class ExceptionMapperITCase extends AbstractITCase {
+
- private static final Properties props = new Properties();
++ private static final Properties ERROR_MESSAGES = new Properties();
+
+ @BeforeClass
+ public static void setUpErrorMessages() throws IOException {
+ InputStream propStream = null;
+ try {
+ propStream = ExceptionMapperITCase.class.getResourceAsStream("/errorMessages.properties");
- props.load(propStream);
++ ERROR_MESSAGES.load(propStream);
+ } catch (Exception e) {
+ LOG.error("Could not load /errorMessages.properties", e);
+ } finally {
+ IOUtils.closeQuietly(propStream);
+ }
+ }
+
+ @Test
+ public void uniqueSchemaConstraint() {
+ // 1. create an user schema with unique constraint
+ PlainSchemaTO schemaTO = new PlainSchemaTO();
- String schema_UID = getUUIDString();
- schemaTO.setKey("unique" + schema_UID);
++ String schemaUID = getUUIDString();
++ schemaTO.setKey("unique" + schemaUID);
+ schemaTO.setType(AttrSchemaType.String);
+ schemaTO.setUniqueConstraint(true);
+ createSchema(AttributableType.USER, SchemaType.PLAIN, schemaTO);
+
+ // 2. create an user with mandatory attributes and unique
- UserTO userTO_1 = new UserTO();
- String userId_1 = getUUIDString() + "issue654_1@syncope.apache.org";
- userTO_1.setUsername(userId_1);
- userTO_1.setPassword("password");
-
- userTO_1.getPlainAttrs().add(attrTO("userId", userId_1));
- userTO_1.getPlainAttrs().add(attrTO("fullname", userId_1));
- userTO_1.getPlainAttrs().add(attrTO("surname", userId_1));
- userTO_1.getPlainAttrs().add(attrTO("unique" + schema_UID, "unique" + schema_UID));
-
- createUser(userTO_1);
-
- // 3. create an other user with mandatory attributes and unique with the same value of userTO_1
- UserTO userTO_2 = new UserTO();
- String userId_2 = getUUIDString() + "issue654_2@syncope.apache.org";
- userTO_2.setUsername(userId_2);
- userTO_2.setPassword("password");
-
- userTO_2.getPlainAttrs().add(attrTO("userId", userId_2));
- userTO_2.getPlainAttrs().add(attrTO("fullname", userId_2));
- userTO_2.getPlainAttrs().add(attrTO("surname", userId_2));
- userTO_2.getPlainAttrs().add(attrTO("unique" + schema_UID, "unique" + schema_UID));
++ UserTO userTO1 = new UserTO();
++ userTO1.setRealm(SyncopeConstants.ROOT_REALM);
++ String userId1 = getUUIDString() + "issue654_1@syncope.apache.org";
++ userTO1.setUsername(userId1);
++ userTO1.setPassword("password123");
++
++ userTO1.getPlainAttrs().add(attrTO("userId", userId1));
++ userTO1.getPlainAttrs().add(attrTO("fullname", userId1));
++ userTO1.getPlainAttrs().add(attrTO("surname", userId1));
++ userTO1.getPlainAttrs().add(attrTO("unique" + schemaUID, "unique" + schemaUID));
++
++ createUser(userTO1);
++
++ // 3. create an other user with mandatory attributes and unique with the same value of userTO1
++ UserTO userTO2 = new UserTO();
++ userTO2.setRealm(SyncopeConstants.ROOT_REALM);
++ String userId2 = getUUIDString() + "issue654_2@syncope.apache.org";
++ userTO2.setUsername(userId2);
++ userTO2.setPassword("password123");
++
++ userTO2.getPlainAttrs().add(attrTO("userId", userId2));
++ userTO2.getPlainAttrs().add(attrTO("fullname", userId2));
++ userTO2.getPlainAttrs().add(attrTO("surname", userId2));
++ userTO2.getPlainAttrs().add(attrTO("unique" + schemaUID, "unique" + schemaUID));
+
+ try {
- createUser(userTO_2);
++ createUser(userTO2);
++ fail();
+ } catch (Exception e) {
- String message = props.getProperty("errMessage.UniqueConstraintViolation");
- Assert.assertEquals(e.getMessage(), "DataIntegrityViolation [" + message + "]");
++ String message = ERROR_MESSAGES.getProperty("errMessage.UniqueConstraintViolation");
++ assertEquals(e.getMessage(), "DataIntegrityViolation [" + message + "]");
+ }
+ }
+
+ @Test
+ public void sameRoleName() {
- //Create the first role
- RoleTO roleTO_1 = new RoleTO();
- String role_UUID = getUUIDString();
- roleTO_1.setName("child1" + role_UUID);
- roleTO_1.setParent(1L);
- createRole(roleTO_1);
- //Create the second role, with the same parent and the same role of roleTO_1
- RoleTO roleTO_2 = new RoleTO();
- roleTO_2.setName("child1" + role_UUID);
- roleTO_2.setParent(1L);
++ // Create the first role
++ RoleTO roleTO1 = new RoleTO();
++ String roleUUID = getUUIDString();
++ roleTO1.setName("child1" + roleUUID);
++ createRole(roleTO1);
++
++ // Create the second role, with the same parent and the same role of roleTO1
++ RoleTO roleTO2 = new RoleTO();
++ roleTO2.setName("child1" + roleUUID);
+ try {
- createRole(roleTO_2);
++ createRole(roleTO2);
++ fail();
+ } catch (Exception e) {
- String message = props.getProperty("errMessage.UniqueConstraintViolation");
- Assert.assertEquals(e.getMessage(), "DataIntegrityViolation [" + message + "]");
++ String message = ERROR_MESSAGES.getProperty("errMessage.UniqueConstraintViolation");
++ assertEquals(e.getMessage(), "DataIntegrityViolation [" + message + "]");
+ }
+ }
+
+ @Test
+ public void headersMultiValue() {
+ UserTO userTO = new UserTO();
++ userTO.setRealm(SyncopeConstants.ROOT_REALM);
+ String userId = getUUIDString() + "issue654@syncope.apache.org";
+ userTO.setUsername(userId);
- userTO.setPassword("password");
++ userTO.setPassword("password123");
+
+ userTO.getPlainAttrs().add(attrTO("userId", "issue654"));
+ userTO.getPlainAttrs().add(attrTO("fullname", userId));
+ userTO.getPlainAttrs().add(attrTO("surname", userId));
+
+ try {
+ createUser(userTO);
+ fail();
+ } catch (SyncopeClientCompositeException e) {
+ assertEquals(2, e.getExceptions().size());
+ }
+ }
+ }
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/SyncTaskITCase.java
----------------------------------------------------------------------
diff --cc fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/SyncTaskITCase.java
index c922413,6e8f213..f0e9920
--- a/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/SyncTaskITCase.java
+++ b/fit/core-reference/src/test/java/org/apache/syncope/fit/core/reference/SyncTaskITCase.java
@@@ -30,8 -29,7 +30,10 @@@ import java.util.HashSet
import java.util.List;
import java.util.Set;
import javax.ws.rs.core.Response;
++import org.apache.commons.collections4.CollectionUtils;
++import org.apache.commons.collections4.Predicate;
import org.apache.syncope.client.lib.SyncopeClient;
+import org.apache.syncope.common.lib.SyncopeConstants;
import org.apache.syncope.common.lib.mod.StatusMod;
import org.apache.syncope.common.lib.mod.UserMod;
import org.apache.syncope.common.lib.to.AbstractTaskTO;
@@@ -183,7 -179,15 +185,15 @@@ public class SyncTaskITCase extends Abs
assertTrue(userTO.getMemberships().get(0).getPlainAttrMap().containsKey("subscriptionDate"));
// Unmatching --> Assign (link)
+ // SYNCOPE-658
assertTrue(userTO.getResources().contains(RESOURCE_NAME_CSV));
- int counter = 0;
- for (AttrTO attributeTO : userTO.getDerAttrs()) {
- if ("csvuserid".equals(attributeTO.getSchema())) {
- counter++;
++ assertEquals(1, CollectionUtils.countMatches(userTO.getDerAttrs(), new Predicate<AttrTO>() {
++
++ @Override
++ public boolean evaluate(final AttrTO attributeTO) {
++ return "csvuserid".equals(attributeTO.getSchema());
+ }
- }
- assertEquals(1, counter);
++ }));
userTO = readUser("test8");
assertNotNull(userTO);
http://git-wip-us.apache.org/repos/asf/syncope/blob/4115c57b/pom.xml
----------------------------------------------------------------------
diff --cc pom.xml
index cc4ee0a,b57900f..0c34a76
--- a/pom.xml
+++ b/pom.xml
@@@ -357,10 -357,9 +357,10 @@@ under the License
<commons-codec.version>1.10</commons-codec.version>
<commons-jexl.version>2.1.1</commons-jexl.version>
<commons-lang.version>3.4</commons-lang.version>
- <commons.logging.version>1.1.3</commons.logging.version>
+ <commons-collection.version>4.0</commons-collection.version>
+ <commons-logging.version>1.1.3</commons-logging.version>
- <h2.version>1.4.186</h2.version>
+ <h2.version>1.4.187</h2.version>
<junit.version>4.12</junit.version>
<selenium.version>2.45.0</selenium.version>