This is an automated email from the ASF dual-hosted git repository.

ilgrosso pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/syncope.git


The following commit(s) were added to refs/heads/master by this push:
     new 10d8b15  [SYNCOPE-957] Ensuring the correct password value is 
propagated
10d8b15 is described below

commit 10d8b1549ffc44c8ee3d76ac36dd6d674916e1f8
Author: Francesco Chicchiriccò <[email protected]>
AuthorDate: Fri Feb 21 17:42:05 2020 +0100

    [SYNCOPE-957] Ensuring the correct password value is propagated
---
 .../syncope/core/logic/ReconciliationLogic.java    |   6 +-
 .../core/provisioning/api/MappingManager.java      |   8 +-
 .../core/provisioning/java/MappingManagerImpl.java |  64 ++++---
 .../java/job/report/ReconciliationReportlet.java   |   2 +-
 .../java/propagation/PropagationManagerImpl.java   |   7 +-
 .../stream/StreamAnyObjectPushResultHandler.java   |   3 +-
 .../stream/StreamGroupPushResultHandler.java       |   3 +-
 .../stream/StreamUserPushResultHandler.java        |   3 +-
 .../provisioning/java/ConnectorManagerTest.java    |   7 +-
 .../provisioning/java/MappingManagerImplTest.java  | 205 +++++++++++++++++++++
 10 files changed, 270 insertions(+), 38 deletions(-)

diff --git 
a/core/idm/logic/src/main/java/org/apache/syncope/core/logic/ReconciliationLogic.java
 
b/core/idm/logic/src/main/java/org/apache/syncope/core/logic/ReconciliationLogic.java
index 33713d1..026f209 100644
--- 
a/core/idm/logic/src/main/java/org/apache/syncope/core/logic/ReconciliationLogic.java
+++ 
b/core/idm/logic/src/main/java/org/apache/syncope/core/logic/ReconciliationLogic.java
@@ -181,7 +181,8 @@ public class ReconciliationLogic extends 
AbstractTransactionalLogic<EntityTO> {
             final MappingItem connObjectKeyItem,
             final Provision provision) {
 
-        Pair<String, Set<Attribute>> prepared = 
mappingManager.prepareAttrs(any, null, false, true, provision);
+        Pair<String, Set<Attribute>> prepared = 
mappingManager.prepareAttrsFromAny(
+                any, null, false, true, provision);
         return getOnSyncope(connObjectKeyItem, prepared.getLeft(), 
prepared.getRight());
     }
 
@@ -190,7 +191,8 @@ public class ReconciliationLogic extends 
AbstractTransactionalLogic<EntityTO> {
             final MappingItem connObjectKeyItem,
             final Provision provision) {
 
-        Set<Attribute> attrs = mappingManager.prepareAttrs(account.getOwner(), 
account, null, false, provision);
+        Set<Attribute> attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                account.getOwner(), account, null, false, provision);
         return getOnSyncope(connObjectKeyItem, 
account.getConnObjectKeyValue(), attrs);
     }
 
diff --git 
a/core/provisioning-api/src/main/java/org/apache/syncope/core/provisioning/api/MappingManager.java
 
b/core/provisioning-api/src/main/java/org/apache/syncope/core/provisioning/api/MappingManager.java
index e970512..df6c43f 100644
--- 
a/core/provisioning-api/src/main/java/org/apache/syncope/core/provisioning/api/MappingManager.java
+++ 
b/core/provisioning-api/src/main/java/org/apache/syncope/core/provisioning/api/MappingManager.java
@@ -106,7 +106,7 @@ public interface MappingManager {
      * @param provision provision information
      * @return connObjectLink + prepared attributes
      */
-    Pair<String, Set<Attribute>> prepareAttrs(
+    Pair<String, Set<Attribute>> prepareAttrsFromAny(
             Any<?> any, String password, boolean changePwd, Boolean enable, 
Provision provision);
 
     /**
@@ -114,12 +114,12 @@ public interface MappingManager {
      *
      * @param user given user
      * @param account linked account
-     * @param password clear-text password
+     * @param password user's clear-text password, to use as default value in 
case
      * @param changePwd whether password should be included for propagation 
attributes or not
      * @param provision provision information
      * @return prepared attributes
      */
-    Set<Attribute> prepareAttrs(
+    Set<Attribute> prepareAttrsFromLinkedAccount(
             User user, LinkedAccount account, String password, boolean 
changePwd, Provision provision);
 
     /**
@@ -129,7 +129,7 @@ public interface MappingManager {
      * @param orgUnit provision information
      * @return connObjectLink + prepared attributes
      */
-    Pair<String, Set<Attribute>> prepareAttrs(Realm realm, OrgUnit orgUnit);
+    Pair<String, Set<Attribute>> prepareAttrsFromRealm(Realm realm, OrgUnit 
orgUnit);
 
     /**
      * Set attribute values, according to the given {@link Item}, to any 
object from attribute received from
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/MappingManagerImpl.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/MappingManagerImpl.java
index c2ef89a..7e70f84 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/MappingManagerImpl.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/MappingManagerImpl.java
@@ -270,7 +270,7 @@ public class MappingManagerImpl implements MappingManager {
 
     @Transactional(readOnly = true)
     @Override
-    public Pair<String, Set<Attribute>> prepareAttrs(
+    public Pair<String, Set<Attribute>> prepareAttrsFromAny(
             final Any<?> any,
             final String password,
             final boolean changePwd,
@@ -335,7 +335,7 @@ public class MappingManagerImpl implements MappingManager {
 
     @Transactional(readOnly = true)
     @Override
-    public Set<Attribute> prepareAttrs(
+    public Set<Attribute> prepareAttrsFromLinkedAccount(
             final User user,
             final LinkedAccount account,
             final String password,
@@ -396,6 +396,12 @@ public class MappingManagerImpl implements MappingManager {
         if (account.isSuspended() != null) {
             
attributes.add(AttributeBuilder.buildEnabled(!BooleanUtils.negate(account.isSuspended())));
         }
+        if (!changePwd) {
+            Attribute pwdAttr = 
AttributeUtil.find(OperationalAttributes.PASSWORD_NAME, attributes);
+            if (pwdAttr != null) {
+                attributes.remove(pwdAttr);
+            }
+        }
 
         return attributes;
     }
@@ -422,7 +428,7 @@ public class MappingManagerImpl implements MappingManager {
     }
 
     @Override
-    public Pair<String, Set<Attribute>> prepareAttrs(final Realm realm, final 
OrgUnit orgUnit) {
+    public Pair<String, Set<Attribute>> prepareAttrsFromRealm(final Realm 
realm, final OrgUnit orgUnit) {
         LOG.debug("Preparing resource attributes for {} with orgUnit {}", 
realm, orgUnit);
 
         Set<Attribute> attributes = new HashSet<>();
@@ -470,21 +476,38 @@ public class MappingManagerImpl implements MappingManager 
{
         return Pair.of(connObjectKeyValue[0], attributes);
     }
 
+    protected String decodePassword(final Account account) {
+        try {
+            return ENCRYPTOR.decode(account.getPassword(), 
account.getCipherAlgorithm());
+        } catch (Exception e) {
+            LOG.error("Could not decode password for {}", account, e);
+            return null;
+        }
+    }
+
     protected String getPasswordAttrValue(final Provision provision, final 
Account account, final String defaultValue) {
-        String passwordAttrValue = defaultValue;
-        if (StringUtils.isBlank(passwordAttrValue)) {
-            if (account.canDecodePassword()) {
-                try {
-                    passwordAttrValue = 
ENCRYPTOR.decode(account.getPassword(), account.getCipherAlgorithm());
-                } catch (Exception e) {
-                    LOG.error("Could not decode password for {}", account, e);
-                }
-            } else if (provision.getResource().isRandomPwdIfNotProvided()) {
-                try {
-                    passwordAttrValue = 
passwordGenerator.generate(provision.getResource());
-                } catch (InvalidPasswordRuleConf e) {
-                    LOG.error("Could not generate policy-compliant random 
password for {}", account, e);
-                }
+        String passwordAttrValue;
+        if (account instanceof LinkedAccount) {
+            if (((LinkedAccount) account).getPassword() != null) {
+                passwordAttrValue = decodePassword(account);
+            } else {
+                passwordAttrValue = defaultValue;
+            }
+        } else {
+            if (StringUtils.isNotBlank(defaultValue)) {
+                passwordAttrValue = defaultValue;
+            } else if (account.canDecodePassword()) {
+                passwordAttrValue = decodePassword(account);
+            } else {
+                passwordAttrValue = null;
+            }
+        }
+
+        if (passwordAttrValue == null && 
provision.getResource().isRandomPwdIfNotProvided()) {
+            try {
+                passwordAttrValue = 
passwordGenerator.generate(provision.getResource());
+            } catch (InvalidPasswordRuleConf e) {
+                LOG.error("Could not generate policy-compliant random password 
for {}", account, e);
             }
         }
 
@@ -853,8 +876,8 @@ public class MappingManagerImpl implements MappingManager {
     public Optional<String> getConnObjectKeyValue(final Any<?> any, final 
Provision provision) {
         Optional<? extends MappingItem> connObjectKeyItem = 
provision.getMapping().getConnObjectKeyItem();
         if (connObjectKeyItem.isEmpty()) {
-             LOG.error("Unable to locate conn object key item for " + 
provision.getMapping().getKey());
-             return Optional.empty();
+            LOG.error("Unable to locate conn object key item for " + 
provision.getMapping().getKey());
+            return Optional.empty();
         }
         MappingItem mapItem = connObjectKeyItem.get();
         Pair<AttrSchemaType, List<PlainAttrValue>> intValues;
@@ -883,8 +906,7 @@ public class MappingManagerImpl implements MappingManager {
             LOG.error("Unable to locate conn object key item for " + 
orgUnit.getKey());
             return Optional.empty();
         }
-        OrgUnitItem orgUnitItem = connObjectKeyItem.get();
-        return Optional.ofNullable(getIntValue(realm, orgUnitItem));
+        return Optional.ofNullable(getIntValue(realm, 
connObjectKeyItem.get()));
     }
 
     @Transactional(readOnly = true)
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/job/report/ReconciliationReportlet.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/job/report/ReconciliationReportlet.java
index de53da9..27e1a0a 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/job/report/ReconciliationReportlet.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/job/report/ReconciliationReportlet.java
@@ -303,7 +303,7 @@ public class ReconciliationReportlet extends 
AbstractReportlet {
                     } else {
                         // 3. found but misaligned?
                         Pair<String, Set<Attribute>> preparedAttrs =
-                                mappingManager.prepareAttrs(any, null, false, 
null, provision);
+                                mappingManager.prepareAttrsFromAny(any, null, 
false, null, provision);
                         preparedAttrs.getRight().add(AttributeBuilder.build(
                                 Uid.NAME, preparedAttrs.getLeft()));
                         preparedAttrs.getRight().add(AttributeBuilder.build(
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/propagation/PropagationManagerImpl.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/propagation/PropagationManagerImpl.java
index 9f7b979..8d603c6 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/propagation/PropagationManagerImpl.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/propagation/PropagationManagerImpl.java
@@ -516,7 +516,7 @@ public class PropagationManagerImpl implements 
PropagationManager {
                         any.getType(), resource);
             } else {
                 Pair<String, Set<Attribute>> preparedAttrs =
-                        mappingManager.prepareAttrs(any, password, changePwd, 
enable, provision);
+                        mappingManager.prepareAttrsFromAny(any, password, 
changePwd, enable, provision);
                 if (vAttrMap.containsKey(resourceKey)) {
                     preparedAttrs.getRight().addAll(vAttrMap.get(resourceKey));
                 }
@@ -574,7 +574,8 @@ public class PropagationManagerImpl implements 
PropagationManager {
                             deleteOnResource,
                             mappingItems,
                             Pair.of(account.getConnObjectKeyValue(),
-                                    mappingManager.prepareAttrs(user, account, 
password, changePwd, provision)));
+                                    
mappingManager.prepareAttrsFromLinkedAccount(
+                                            user, account, password, true, 
provision)));
                     tasks.add(accountTask);
 
                     LOG.debug("PropagationTask created for Linked Account {}: 
{}",
@@ -622,7 +623,7 @@ public class PropagationManagerImpl implements 
PropagationManager {
                 task.setOperation(operation);
                 
task.setOldConnObjectKey(propByRes.getOldConnObjectKey(resource.getKey()));
 
-                Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrs(realm, orgUnit);
+                Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrsFromRealm(realm, orgUnit);
                 task.setConnObjectKey(preparedAttrs.getLeft());
                 
task.setAttributes(POJOHelper.serialize(preparedAttrs.getRight()));
 
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamAnyObjectPushResultHandler.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamAnyObjectPushResultHandler.java
index 17576cb..918c2a5 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamAnyObjectPushResultHandler.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamAnyObjectPushResultHandler.java
@@ -52,7 +52,8 @@ public class StreamAnyObjectPushResultHandler extends 
DefaultAnyObjectPushResult
 
         Stream<? extends Item> items = 
MappingUtils.getPropagationItems(provision.getMapping().getItems().stream());
 
-        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrs(any, null, false, enabled, provision);
+        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrsFromAny(
+                any, null, false, enabled, provision);
 
         PropagationTaskInfo propagationTask = propagationManager.newTask(
                 derAttrHandler,
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamGroupPushResultHandler.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamGroupPushResultHandler.java
index 32e6710..ad169fd 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamGroupPushResultHandler.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamGroupPushResultHandler.java
@@ -52,7 +52,8 @@ public class StreamGroupPushResultHandler extends 
DefaultGroupPushResultHandler
 
         Stream<? extends Item> items = 
MappingUtils.getPropagationItems(provision.getMapping().getItems().stream());
 
-        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrs(any, null, false, enabled, provision);
+        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrsFromAny(
+                any, null, false, enabled, provision);
 
         PropagationTaskInfo propagationTask = propagationManager.newTask(
                 derAttrHandler,
diff --git 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamUserPushResultHandler.java
 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamUserPushResultHandler.java
index 9b788a0..e2b3446 100644
--- 
a/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamUserPushResultHandler.java
+++ 
b/core/provisioning-java/src/main/java/org/apache/syncope/core/provisioning/java/pushpull/stream/StreamUserPushResultHandler.java
@@ -52,7 +52,8 @@ public class StreamUserPushResultHandler extends 
DefaultUserPushResultHandler {
 
         Stream<? extends Item> items = 
MappingUtils.getPropagationItems(provision.getMapping().getItems().stream());
 
-        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrs(any, null, false, enabled, provision);
+        Pair<String, Set<Attribute>> preparedAttrs = 
mappingManager.prepareAttrsFromAny(
+                any, null, false, enabled, provision);
 
         PropagationTaskInfo propagationTask = propagationManager.newTask(
                 derAttrHandler,
diff --git 
a/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/ConnectorManagerTest.java
 
b/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/ConnectorManagerTest.java
index 4908820..40a1b5c 100644
--- 
a/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/ConnectorManagerTest.java
+++ 
b/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/ConnectorManagerTest.java
@@ -33,14 +33,14 @@ import 
org.springframework.transaction.annotation.Transactional;
 @Transactional("Master")
 public class ConnectorManagerTest extends AbstractTest {
 
-    private ConnectorManager connManager;
-
     @Autowired
     private ConnIdBundleManager connIdBundleManager;
 
     @Autowired
     private ExternalResourceDAO resourceDAO;
 
+    private ConnectorManager connManager;
+
     @BeforeEach
     public void before() {
         connManager = new ConnectorManager();
@@ -60,7 +60,6 @@ public class ConnectorManagerTest extends AbstractTest {
                 filter(resource -> 
resource.getConnector().getLocation().startsWith("file")).count();
 
         assertEquals(expected,
-                ApplicationContextProvider.getBeanFactory().
-                        getBeanNamesForType(Connector.class, false, 
true).length);
+                
ApplicationContextProvider.getBeanFactory().getBeanNamesForType(Connector.class,
 false, true).length);
     }
 }
diff --git 
a/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/MappingManagerImplTest.java
 
b/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/MappingManagerImplTest.java
new file mode 100644
index 0000000..efedfaf
--- /dev/null
+++ 
b/core/provisioning-java/src/test/java/org/apache/syncope/core/provisioning/java/MappingManagerImplTest.java
@@ -0,0 +1,205 @@
+/*
+ * 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.provisioning.java;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.util.Set;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.syncope.common.lib.types.AnyTypeKind;
+import org.apache.syncope.common.lib.types.CipherAlgorithm;
+import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.EntityFactory;
+import 
org.apache.syncope.core.persistence.api.entity.resource.ExternalResource;
+import org.apache.syncope.core.persistence.api.entity.resource.Provision;
+import org.apache.syncope.core.persistence.api.entity.user.LinkedAccount;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.provisioning.api.MappingManager;
+import org.identityconnectors.common.security.SecurityUtil;
+import org.identityconnectors.framework.common.objects.Attribute;
+import org.identityconnectors.framework.common.objects.AttributeUtil;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional("Master")
+public class MappingManagerImplTest extends AbstractTest {
+
+    @Autowired
+    private MappingManager mappingManager;
+
+    @Autowired
+    private UserDAO userDAO;
+
+    @Autowired
+    private ExternalResourceDAO resourceDAO;
+
+    @Autowired
+    private EntityFactory entityFactory;
+
+    @Test
+    public void prepareAttrsForUser() {
+        User bellini = userDAO.findByUsername("bellini");
+        ExternalResource ldap = resourceDAO.find("resource-ldap");
+        Provision provision = ldap.getProvision(AnyTypeKind.USER.name()).get();
+
+        assertNotEquals(CipherAlgorithm.AES, bellini.getCipherAlgorithm());
+
+        // 1. with clear-text password
+        Pair<String, Set<Attribute>> attrs = 
mappingManager.prepareAttrsFromAny(
+                bellini,
+                "Password123",
+                true,
+                Boolean.TRUE,
+                provision);
+        assertEquals("bellini", attrs.getLeft());
+        assertEquals(
+                "uid=bellini,ou=people,o=isp",
+                
AttributeUtil.getNameFromAttributes(attrs.getRight()).getNameValue());
+        assertEquals("Password123", 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs.getRight())));
+
+        // 2. with changePwd == false
+        attrs = mappingManager.prepareAttrsFromAny(
+                bellini,
+                "Password123",
+                false,
+                Boolean.TRUE,
+                provision);
+        assertNull(AttributeUtil.getPasswordValue(attrs.getRight()));
+
+        // 3. with no clear-text password but random password generation 
enabled
+        ldap.setRandomPwdIfNotProvided(true);
+        ldap = resourceDAO.save(ldap);
+        entityManager().flush();
+
+        String encPassword = bellini.getPassword();
+        attrs = mappingManager.prepareAttrsFromAny(
+                bellini,
+                null,
+                true,
+                Boolean.TRUE,
+                provision);
+        assertNotEquals(encPassword, 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs.getRight())));
+
+        // 4. with no clear-text password and random password generation 
disabled
+        ldap.setRandomPwdIfNotProvided(false);
+        resourceDAO.save(ldap);
+        entityManager().flush();
+
+        attrs = mappingManager.prepareAttrsFromAny(
+                bellini,
+                null,
+                true,
+                Boolean.TRUE,
+                provision);
+        assertNull(AttributeUtil.getPasswordValue(attrs.getRight()));
+
+        // 5. with no clear-text password, random password generation disabled 
but AES
+        bellini.setPassword("newPassword123", CipherAlgorithm.AES);
+        userDAO.save(bellini);
+        entityManager().flush();
+
+        assertEquals(CipherAlgorithm.AES, bellini.getCipherAlgorithm());
+
+        attrs = mappingManager.prepareAttrsFromAny(
+                bellini,
+                null,
+                true,
+                Boolean.TRUE,
+                provision);
+        assertEquals("newPassword123", 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs.getRight())));
+    }
+
+    @Test
+    public void prepareAttrsForLinkedAccount() {
+        User vivaldi = userDAO.findByUsername("vivaldi");
+        ExternalResource ldap = resourceDAO.find("resource-ldap");
+        Provision provision = ldap.getProvision(AnyTypeKind.USER.name()).get();
+
+        LinkedAccount account = entityFactory.newEntity(LinkedAccount.class);
+        account.setConnObjectKeyValue("admin");
+        account.setResource(ldap);
+        account.setOwner(vivaldi);
+        account.setPassword("Password321", CipherAlgorithm.AES);
+        vivaldi.add(account);
+
+        vivaldi = userDAO.save(vivaldi);
+        entityManager().flush();
+
+        // 1. with account password and clear-text default password
+        Set<Attribute> attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                vivaldi,
+                account,
+                "Password123",
+                true,
+                provision);
+        assertEquals("admin", 
AttributeUtil.getStringValue(AttributeUtil.find("cn", attrs)));
+        assertEquals("Password321", 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs)));
+
+        // 2. without account password and clear-text default password
+        account.setEncodedPassword(null, null);
+
+        attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                vivaldi,
+                account,
+                "Password123",
+                true,
+                provision);
+        assertEquals("Password123", 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs)));
+
+        // 3. with changePwd == false
+        attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                vivaldi,
+                account,
+                "Password123",
+                false,
+                provision);
+        assertNull(AttributeUtil.getPasswordValue(attrs));
+
+        // 4. without account password, no clear-text password but random 
password generation enabled
+        ldap.setRandomPwdIfNotProvided(true);
+        ldap = resourceDAO.save(ldap);
+        entityManager().flush();
+
+        String encPassword = vivaldi.getPassword();
+        attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                vivaldi,
+                account,
+                null,
+                true,
+                provision);
+        assertNotEquals(encPassword, 
SecurityUtil.decrypt(AttributeUtil.getPasswordValue(attrs)));
+
+        // 5. without account password, no clear-text password and random 
password generation disabled
+        ldap.setRandomPwdIfNotProvided(false);
+        resourceDAO.save(ldap);
+        entityManager().flush();
+
+        attrs = mappingManager.prepareAttrsFromLinkedAccount(
+                vivaldi,
+                account,
+                null,
+                true,
+                provision);
+        assertNull(AttributeUtil.getPasswordValue(attrs));
+    }
+}

Reply via email to