Java 类javax.naming.directory.ModificationItem 实例源码

/**
 * Lock an user :
 * <ul>
 * <li>Clear the password to prevent new authentication</li>
 * <li>Set the disabled flag.</li>
 * </ul>
 * 
 * @param principal
 *            User requesting the lock.
 * @param user
 *            The LDAP user to disable.
 * @param isolate
 *            When <code>true</code>, the user will be isolated in addition.
 */
private void lock(final String principal, final UserOrg user, final boolean isolate) {
    if (user.getLockedBy() == null) {
        // Not yet locked
        final ModificationItem[] mods = new ModificationItem[2];
        final long timeInMillis = DateUtils.newCalendar().getTimeInMillis();
        mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute(lockedAttribute,
                String.format("%s|%s|%s|%s|", lockedValue, timeInMillis, principal, isolate ? user.getCompany() : "")));
        mods[1] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute(PASSWORD_ATTRIBUTE, null));
        template.modifyAttributes(org.springframework.ldap.support.LdapUtils.newLdapName(user.getDn()), mods);

        // Also update the disabled date
        user.setLocked(new Date(timeInMillis));
        user.setLockedBy(principal);
    }
}

/**
 * Remove an "uniqueMember" from given group. Cache is not updated there.
 * 
 * @param uniqueMember
 *            DN of the member to remove.
 * @param group
 *            CN of the group to update. Must be normalized.
 * @return the {@link GroupOrg} where the member has just been removed from.
 */
private GroupOrg removeMember(final ResourceOrg uniqueMember, final String group) {
    final GroupOrg groupLdap = findById(group);
    if (groupLdap.getMembers().contains(uniqueMember.getId()) || groupLdap.getSubGroups().contains(uniqueMember.getId())) {
        // Not useless LDAP operation, avoid LDAP duplicate deletion
        final ModificationItem[] mods = new ModificationItem[1];
        mods[0] = new ModificationItem(DirContext.REMOVE_ATTRIBUTE, new BasicAttribute(UNIQUE_MEMBER, uniqueMember.getDn()));
        try {
            template.modifyAttributes(org.springframework.ldap.support.LdapUtils.newLdapName(groupLdap.getDn()), mods);
        } catch (final org.springframework.ldap.AttributeInUseException aiue) {
            // Even if the membership update failed, the user does not exist anymore. A broken reference can remains
            // in LDAP, but this case is well managed.
            log.info("Unable to remove user {} from the group {} : {}", uniqueMember.getDn(), group, aiue);
        } catch (final org.springframework.ldap.SchemaViolationException sve) { // NOSONAR - Exception is logged
            // Occurs when there is a LDAP schema violation such as as last member removed
            log.warn("Unable to remove user {} from the group {}", uniqueMember.getDn(), group, sve);
            throw new ValidationJsonException("groups", "last-member-of-group", "user", uniqueMember.getId(), "group", group);
        }
    }
    return groupLdap;
}

@Override
public void addAttributes(final String dn, final String attribute, final Collection<String> values) {
    if (values.isEmpty()) {
        // Ignore this call
        return;
    }

    // Build the modification operation
    final ModificationItem[] mods = values.stream().map(v -> new ModificationItem(DirContext.ADD_ATTRIBUTE, new BasicAttribute(attribute, v)))
            .toArray(ModificationItem[]::new);
    try {
        // Perform the addition
        template.modifyAttributes(org.springframework.ldap.support.LdapUtils.newLdapName(dn), mods);
    } catch (final org.springframework.ldap.AttributeInUseException aiue) {
        if (!aiue.getMessage().matches(".*(value #0 already exists|error code 20|ATTRIBUTE_OR_VALUE_EXISTS).*")) {
            throw aiue;
        }
        log.info("{} is already member of {}", values, dn);
    }
}

/**
 * This seems to be required for objectClass posixGroup.
 */
private ApacheDS activateNis() throws Exception {
  Preconditions.checkState(ldapServer.isStarted());

  Attribute disabled = new BasicAttribute("m-disabled", "TRUE");
  Attribute disabled2 = new BasicAttribute("m-disabled", "FALSE");
  ModificationItem[] mods = new ModificationItem[] {
    new ModificationItem(DirContext.REMOVE_ATTRIBUTE, disabled),
    new ModificationItem(DirContext.ADD_ATTRIBUTE, disabled2)
  };

  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
  env.put(Context.PROVIDER_URL, getUrl());

  DirContext ctx = new InitialDirContext(env);
  ctx.modifyAttributes("cn=nis,ou=schema", mods);

  return this;
}

/**
 * 
 * Convert a list of ModificationItemImpl to a list of 
 *
 * @param modificationImpls
 * @param atRegistry
 * @return
 * @throws LdapException
 */
public static List<Modification> convertToServerModification( List<ModificationItem> modificationItems,
    SchemaManager schemaManager ) throws LdapException
{
    if ( modificationItems != null )
    {
        List<Modification> modifications = new ArrayList<Modification>( modificationItems.size() );

        for ( ModificationItem modificationItem : modificationItems )
        {
            AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( modificationItem
                .getAttribute().getID() );
            modifications.add( toServerModification( modificationItem, attributeType ) );
        }

        return modifications;
    }
    else
    {
        return null;
    }
}

/**
 * 
 * Convert a list of ModificationItemImpl to a list of 
 *
 * @param modificationImpls
 * @param atRegistry
 * @return
 * @throws LdapException
 */
public static List<Modification> convertToServerModification( List<ModificationItem> modificationItems,
    SchemaManager schemaManager ) throws LdapException
{
    if ( modificationItems != null )
    {
        List<Modification> modifications = new ArrayList<Modification>( modificationItems.size() );

        for ( ModificationItem modificationItem : modificationItems )
        {
            AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( modificationItem
                .getAttribute().getID() );
            modifications.add( toServerModification( modificationItem, attributeType ) );
        }

        return modifications;
    }
    else
    {
        return null;
    }
}

public void changePassord(ServiceContext serviceContext, User user, String password) throws Exception{
    long companyId = serviceContext.getCompanyId();
    Properties userMappings = getUserMappings(serviceContext.getCompanyId());
    Binding binding = getUser(companyId, user.getScreenName());
    System.out.println("bingging " + binding);
    System.out.println("Pass " + user.getPassword());
    String name = StringPool.BLANK;
    StringBuilder sb = new StringBuilder();
    LdapContext ctx = getContext(serviceContext.getCompanyId());
       sb = new StringBuilder();
    sb.append(userMappings.getProperty("screenName"));
    sb.append(StringPool.EQUAL);
    sb.append(user.getScreenName());
    sb.append(StringPool.COMMA);
    sb.append(getUsersDN(companyId));
    name = sb.toString();
    Modifications mods = Modifications.getInstance();  

    mods.addItem(userMappings.getProperty(UserConverterKeys.PASSWORD),password);
    ModificationItem[] modItems = mods.getItems();
    if (binding != null) {
        ctx.modifyAttributes(name, modItems);
    }

}

public void updateLdapZimbra(LdapContext ctx ,User user,String name, Employee emp) throws NamingException{
    Modifications mods = Modifications.getInstance();
       for (int i = 0; i < 5;i++){
         mods.addItem(zimbraProperty[i][0],zimbraProperty[i][1]);
       }
       mods.addItem("zimbramaildeliveryaddress",user.getEmailAddress());

      // mods.addItem("company",user.getEmailAddress());
     //  mods.addItem("street",user.getEmailAddress());
      //.addItem("company",user.getEmailAddress());
      // mods.addItem("company",user.getEmailAddress());
    //System.out.println("My  " + mods);
       ModificationItem[] modItems = mods.getItems();
       ctx.modifyAttributes(name, modItems);
       //= getContext(serviceContext.getCompanyId());

}

/**
 * Function for instance_admin to reset user password 
 */
public boolean resetUserPassword(String usrDn, String pw) {
    DirContext context = null;

    try {
        context = getContext();
        Attribute userPassword = new BasicAttribute(LdapManager.PERSON_PASSWORD, hash256(pw));
        ModificationItem[] mods = new ModificationItem[1];
        mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, userPassword);
        context.modifyAttributes(usrDn, mods);
        logger.info("LdapManager info: User '"+usrDn+"' password reseted by instance_admin.");
        context.close();

    } catch (NamingException e) {
        logger.error("LdapManager error: Error reseting user password, "+e);
        return false;
    }

    return true;
}

@Test public void testUpdate() throws Exception {
      String input = "exec native('update;uid=doe,ou=people,o=teiid.org;attributes=one,two,three', 'one', 2, 3.0)"; 

      TranslationUtility util = FakeTranslationFactory.getInstance().getExampleTranslationUtility();
      Command command = util.parseCommand(input);
      ExecutionContext ec = Mockito.mock(ExecutionContext.class);
      RuntimeMetadata rm = Mockito.mock(RuntimeMetadata.class);
      LdapContext connection = Mockito.mock(LdapContext.class);
      LdapContext ctx = Mockito.mock(LdapContext.class);
      Mockito.stub(connection.lookup("")).toReturn(ctx);

      LDAPDirectCreateUpdateDeleteQueryExecution execution = (LDAPDirectCreateUpdateDeleteQueryExecution)TRANSLATOR.createExecution(command, ec, rm, connection);
execution.execute();

ArgumentCaptor<String> nameArgument = ArgumentCaptor.forClass(String.class);
ArgumentCaptor<ModificationItem[]> modificationItemArgument = ArgumentCaptor.forClass(ModificationItem[].class);
Mockito.verify(ctx).modifyAttributes(nameArgument.capture(),modificationItemArgument.capture());

assertEquals("uid=doe,ou=people,o=teiid.org", nameArgument.getValue());
assertEquals("one", modificationItemArgument.getValue()[0].getAttribute().getID());
assertEquals("one", modificationItemArgument.getValue()[0].getAttribute().get());
assertEquals("two", modificationItemArgument.getValue()[1].getAttribute().getID());
assertEquals("2", modificationItemArgument.getValue()[1].getAttribute().get());
assertEquals("three", modificationItemArgument.getValue()[2].getAttribute().getID());
assertEquals("3.0", modificationItemArgument.getValue()[2].getAttribute().get());
  }

@Test public void testUpdateNull() throws Exception {
      String sql = "update LdapModel.People set userid = 1, name = null where dn = 'x'"; //$NON-NLS-1$

      QueryMetadataInterface metadata = exampleLdap();

      Update query = (Update)getCommand(sql, metadata);

      LDAPExecutionFactory config = new LDAPExecutionFactory();

      LdapContext context = Mockito.mock(LdapContext.class);

      Mockito.stub(context.lookup("")).toReturn(context);

LDAPUpdateExecution lue = new LDAPUpdateExecution(query, context);

      lue.execute();
      ArgumentCaptor<ModificationItem[]> captor = ArgumentCaptor.forClass(ModificationItem[].class);
      Mockito.verify(context).modifyAttributes(ArgumentCaptor.forClass(String.class).capture(), captor.capture());
      ModificationItem[] modifications = captor.getValue();
      assertEquals(2, modifications.length);
      assertEquals("uid: 1", modifications[0].getAttribute().toString());
      assertEquals("cn: null", modifications[1].getAttribute().toString());
  }

@Test public void testUpdateArray() throws Exception {
      String sql = "update LdapModel.People set userid = 1, vals = ('a','b') where dn = 'x'"; //$NON-NLS-1$

      QueryMetadataInterface metadata = exampleLdap();

      Update query = (Update)getCommand(sql, metadata);

      LDAPExecutionFactory config = new LDAPExecutionFactory();

      LdapContext context = Mockito.mock(LdapContext.class);

      Mockito.stub(context.lookup("")).toReturn(context);

LDAPUpdateExecution lue = new LDAPUpdateExecution(query, context);

      lue.execute();
      ArgumentCaptor<ModificationItem[]> captor = ArgumentCaptor.forClass(ModificationItem[].class);
      Mockito.verify(context).modifyAttributes(ArgumentCaptor.forClass(String.class).capture(), captor.capture());
      ModificationItem[] modifications = captor.getValue();
      assertEquals(2, modifications.length);
      assertEquals("uid: 1", modifications[0].getAttribute().toString());
      assertEquals("vals: a, b", modifications[1].getAttribute().toString());
  }

private void enableKerberoseSchema() throws DirectoryServerException {
    // check if krb5kdc is disabled
    Attributes krb5kdcAttrs;
    try {
        krb5kdcAttrs = schemaRoot.getAttributes("cn=Krb5kdc");

        boolean isKrb5KdcDisabled = false;
        if (krb5kdcAttrs.get("m-disabled") != null) {
            isKrb5KdcDisabled = "TRUE".equalsIgnoreCase((String) krb5kdcAttrs.get("m-disabled").get());
        }

        // if krb5kdc is disabled then enable it
        if (isKrb5KdcDisabled) {
            Attribute disabled = new BasicAttribute("m-disabled");
            ModificationItem[] mods =
                    new ModificationItem[]{new ModificationItem(
                            DirContext.REMOVE_ATTRIBUTE, disabled)};
            schemaRoot.modifyAttributes("cn=Krb5kdc", mods);
        }
    } catch (NamingException e) {
        String msg = "An error occurred while enabling Kerberos schema.";
        logger.error(msg, e);
        throw new DirectoryServerException(msg, e);
    }
}

/**
 * Function for instance_admin to reset user password 
 */
public boolean resetUserPassword(String usrDn, String pw) {
    DirContext context = null;

    try {
        context = getContext();
        Attribute userPassword = new BasicAttribute(LdapManager.PERSON_PASSWORD, hash256(pw));
        ModificationItem[] mods = new ModificationItem[1];
        mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, userPassword);
        context.modifyAttributes(usrDn, mods);
        logger.info("LdapManager info: User '"+usrDn+"' password reseted by instance_admin.");
        context.close();

    } catch (NamingException e) {
        logger.error("LdapManager error: Error reseting user password, "+e);
        return false;
    }

    return true;
}

/**
 * setupModifications, Setup Bulk Modificationitem from incoming Attributes Object.
 *
 * @param _modtype    Modifcation Type.
 * @param _entryattrs Incoming attributes to be placed into Modificationitem Queue.
 * @throws idxIRRException for any specific IRR unrecoverable errors during function.
 * @throws Exception       for any unrecoverable errors during function.
 */
private void setupModifications(int _modtype, Attributes _entryattrs)
        throws Exception, idxIRRException {

    // **********************************************
    // Check incoming Parameters.
    if (_entryattrs == null) {
        return;
    }

    // **********************************************************
    // Process the incoming Attributes into the Modification Set.
    for (NamingEnumeration ea = _entryattrs.getAll(); ea.hasMore(); ) {
        Attribute attr = (Attribute) ea.next();
        CURRENT_MODLIST.addLast(new ModificationItem(_modtype, attr));
    } // End of For Loop.

    // **********************************************
    // Return
    return;
}

public void modifyAttributes(Name name, ModificationItem[] modificationItems)
        throws NamingException {
    if (!(name instanceof CompositeName)) {
        // jndi.26=URL context can't accept non-composite name: {0}
        throw new InvalidNameException(Messages.getString("jndi.26", name)); //$NON-NLS-1$
    }

    if (name.size() == 1) {
        modifyAttributes(name.get(0), modificationItems);
        return;
    }
    DirContext context = getContinuationContext(name);

    try {
        context.modifyAttributes(name.getSuffix(1), modificationItems);
        return;
    } finally {
        context.close();
    }

}

public void testToString() {
    log.setMethod("testToString()");
    String str;

    AttributeModificationException ex = new AttributeModificationException(
            "sample message");
    str = ex.toString();
    assertTrue(str.indexOf("sample message") >= 0);
    assertFalse(str.indexOf("sample id") >= 0);
    assertFalse(str.indexOf("sample value") >= 0);

    ModificationItem items[] = new ModificationItem[] { new ModificationItem(
            DirContext.ADD_ATTRIBUTE, new BasicAttribute("sample id",
                    "sample value")), };

    ex.setUnexecutedModifications(items);
    str = ex.toString();
    assertTrue(str.indexOf("sample message") >= 0);
    assertTrue(str.indexOf("sample id") >= 0);
    assertTrue(str.indexOf("sample value") >= 0);
}

public void testSetUnexecutedModifications() throws InvalidNameException {
    AttributeModificationException ex1 = new AttributeModificationException(
            "Test 1");
    AttributeModificationException ex2 = new AttributeModificationException(
            "Test 2");
    Name name = new CompositeName("TestSetUnexecutedModifications");
    ex1.setRemainingName(name);
    ex1.setRootCause(ex2);
    ModificationItem[] items = {
            new ModificationItem(DirContext.ADD_ATTRIBUTE,
                    new BasicAttribute("test1")),
            new ModificationItem(DirContext.ADD_ATTRIBUTE,
                    new BasicAttribute("test2")), };
    ex1.setUnexecutedModifications(items);
    assertTrue(ex1.toString(false).equals(ex1.toString()));
    assertTrue(ex1.toString(true).equals(ex1.toString()));
}

@Override
public boolean updatePassword(UserAccount login, String newPasswd) {
    if (login == null) return false;
    String username = login.getLogin();
    log.trace("changePassword called for account: {}", username);

    ModificationItem[] mod = new ModificationItem[1];
    Attribute attr = new BasicAttribute("userpassword", newPasswd);
    mod[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, attr);

    final String dn = configurationService.getStringConfiguration(CONF_DN, "{login}")
            .replaceAll(Pattern.quote("{login}"), username);
    try {
        // ctx.modifyAttributes(dn, mod);
        // log.info("LDAP-Passwd update for {} successful ({})", username, dn);
        // return true;
    } catch (Exception e) {
        log.info("LDAP-Passwd update for {} failed ({})", username, dn);
    }
    log.warn("LDAP-Passwd update not implemented");
    return false;
}

public int update(String dn, String[] attributes, String[] values, boolean checkEntry) throws KettleException {
  try {
    int nrAttributes = attributes.length;
    ModificationItem[] mods = new ModificationItem[nrAttributes];
    for (int i = 0; i < nrAttributes; i++) {
      // Define attribute
      Attribute mod = new BasicAttribute(attributes[i], values[i]);
      if (log.isDebug())
        log.logDebug(BaseMessages.getString(PKG, "LDAPConnection.Update.Attribute", attributes[i], values[i]));
      // Save update action on attribute
      mods[i] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, mod);
    }
    // We have all requested attribute
    // let's update now
    getInitialContext().modifyAttributes(dn, mods);
    return STATUS_UPDATED;
  } catch (NameNotFoundException n) {
    // The entry is not found
    if (checkEntry) {
      throw new KettleException(BaseMessages.getString(PKG, "LDAPConnection.Error.Deleting.NameNotFound", dn), n);
    }
    return STATUS_SKIPPED;
  } catch (Exception e) {
    throw new KettleException(BaseMessages.getString(PKG, "LDAPConnection.Error.Update", dn), e);
  }
}

public void modifyAttributes(Name name, ModificationItem[] modificationItems)
        throws NamingException {
    if (!(name instanceof CompositeName)) {
        // jndi.26=URL context can't accept non-composite name: {0}
        throw new InvalidNameException(Messages.getString("jndi.26", name)); //$NON-NLS-1$
    }

    if (name.size() == 1) {
        modifyAttributes(name.get(0), modificationItems);
        return;
    }
    DirContext context = getContinuationContext(name);

    try {
        context.modifyAttributes(name.getSuffix(1), modificationItems);
        return;
    } finally {
        context.close();
    }

}

@Test
public void testGetCompensatingModificationItem_ReplaceNonExistingAttribute()
        throws NamingException {
    Attributes attributes = new BasicAttributes();

    BasicAttribute modificationAttribute = new BasicAttribute("someattr");
    modificationAttribute.add("newvalue1");
    modificationAttribute.add("newvalue2");
    ModificationItem originalItem = new ModificationItem(
            DirContext.REPLACE_ATTRIBUTE, modificationAttribute);

    // Perform test
    ModificationItem result = tested.getCompensatingModificationItem(
            attributes, originalItem);

    // Verify result
    assertThat(result.getModificationOp()).isEqualTo(DirContext.REMOVE_ATTRIBUTE);
    Attribute resultAttribute = result.getAttribute();
    assertThat(resultAttribute.getID()).isEqualTo("someattr");
    assertThat(resultAttribute.size()).isEqualTo(0);
}

@Test
public void testGetCompensatingModificationItem_AddExistingAttribute()
        throws NamingException {
    BasicAttribute attribute = new BasicAttribute("someattr");
    attribute.add("value1");
    attribute.add("value2");
    Attributes attributes = new BasicAttributes();
    attributes.put(attribute);

    BasicAttribute modificationAttribute = new BasicAttribute("someattr");
    modificationAttribute.add("newvalue1");
    modificationAttribute.add("newvalue2");
    ModificationItem originalItem = new ModificationItem(
            DirContext.ADD_ATTRIBUTE, new BasicAttribute("someattr"));

    // Perform test
    ModificationItem result = tested.getCompensatingModificationItem(
            attributes, originalItem);

    // Verify result
    assertThat(result.getModificationOp()).isEqualTo(DirContext.REPLACE_ATTRIBUTE);
    Attribute resultAttribute = result.getAttribute();
    assertThat(resultAttribute.getID()).isEqualTo("someattr");
    assertThat(result.getAttribute().get(0)).isEqualTo("value1");
    assertThat(result.getAttribute().get(1)).isEqualTo("value2");
}

@Test
public void testGetCompensatingModificationItem_RemoveFullExistingAttribute()
        throws NamingException {
    BasicAttribute attribute = new BasicAttribute("someattr");
    attribute.add("value1");
    attribute.add("value2");
    Attributes attributes = new BasicAttributes();
    attributes.put(attribute);

    ModificationItem originalItem = new ModificationItem(
            DirContext.REMOVE_ATTRIBUTE, new BasicAttribute("someattr"));

    // Perform test
    ModificationItem result = tested.getCompensatingModificationItem(
            attributes, originalItem);

    // Verify result
    assertThat(result.getModificationOp()).isEqualTo(DirContext.ADD_ATTRIBUTE);
    Attribute resultAttribute = result.getAttribute();
    assertThat(resultAttribute.getID()).isEqualTo("someattr");
    Object object = resultAttribute.get(0);
    assertThat(object).isEqualTo("value1");
    assertThat(resultAttribute.get(1)).isEqualTo("value2");
}

@Test
public void testRemoveDnAttributeSyntacticallyEqual() throws NamingException {
    BasicAttributes attributes = new BasicAttributes();
    attributes.put("uniqueMember", "cn=john doe,OU=company");

    DirContextAdapter tested = new DirContextAdapter(attributes, LdapUtils.newLdapName("cn=administrators, ou=groups"));
    tested.setUpdateMode(true);

    tested.removeAttributeValue("uniqueMember", LdapUtils.newLdapName("cn=john doe, ou=company"));
    ModificationItem[] modificationItems = tested.getModificationItems();
    assertThat(modificationItems.length).isEqualTo(1);

    ModificationItem modificationItem = modificationItems[0];
    assertThat(modificationItem.getModificationOp()).isEqualTo(DirContext.REMOVE_ATTRIBUTE);
    assertThat(modificationItem.getAttribute().getID()).isEqualTo("uniqueMember");
}

public void testSetUnexecutedModifications() throws InvalidNameException {
    AttributeModificationException ex1 = new AttributeModificationException(
            "Test 1");
    AttributeModificationException ex2 = new AttributeModificationException(
            "Test 2");
    Name name = new CompositeName("TestSetUnexecutedModifications");
    ex1.setRemainingName(name);
    ex1.setRootCause(ex2);
    ModificationItem[] items = {
            new ModificationItem(DirContext.ADD_ATTRIBUTE,
                    new BasicAttribute("test1")),
            new ModificationItem(DirContext.ADD_ATTRIBUTE,
                    new BasicAttribute("test2")), };
    ex1.setUnexecutedModifications(items);
    assertTrue(ex1.toString(false).equals(ex1.toString()));
    assertTrue(ex1.toString(true).equals(ex1.toString()));
}

@Test
public void testChangeMultiAttributeOrderDoesMatter() throws Exception {
    final Attributes fixtureAttrs = new BasicAttributes();
    Attribute multi = new BasicAttribute("abc");
    multi.add("123");
    multi.add("qwe");
    fixtureAttrs.put(multi);
    class TestableDirContextAdapter extends DirContextAdapter {
        public TestableDirContextAdapter() {
            super(fixtureAttrs, null);
            setUpdateMode(true);
        }
    }
    tested = new TestableDirContextAdapter();
    assertThat(tested.isUpdateMode()).isTrue();
    tested.setAttributeValues("abc", new String[] { "qwe", "123" }, true);

    // change
    ModificationItem[] mods = tested.getModificationItems();
    assertThat(mods.length).isEqualTo(1);
    assertThat(mods[0].getModificationOp()).isEqualTo(DirContext.REPLACE_ATTRIBUTE);
    Attribute attr = mods[0].getAttribute();
    assertThat(attr.get(0)).isEqualTo("qwe");
    assertThat(attr.get(1)).isEqualTo("123");
}

public void modifyAttributes(Name name, ModificationItem[] modificationItems)
        throws NamingException {
    if (!(name instanceof CompositeName)) {
        // jndi.26=URL context can't accept non-composite name: {0}
        throw new InvalidNameException(Messages.getString("jndi.26", name)); //$NON-NLS-1$
    }

    if (name.size() == 1) {
        modifyAttributes(name.get(0), modificationItems);
        return;
    }
    DirContext context = getContinuationContext(name);

    try {
        context.modifyAttributes(name.getSuffix(1), modificationItems);
        return;
    } finally {
        context.close();
    }

}

@Test
public void testRemoveAttributeValueInUpdateModeSameAndOtherValueExistsInOrigAttrs()
        throws NamingException {
    BasicAttribute basicAttribute = new BasicAttribute("abc");
    basicAttribute.add("123");
    basicAttribute.add("321");
    tested.setAttribute(basicAttribute);
    tested.setUpdateMode(true);

    // Perform test
    tested.removeAttributeValue("abc", "123");

    ModificationItem[] modificationItems = tested.getModificationItems();
    assertThat(modificationItems.length).isEqualTo(1);
    Attribute modificationAttribute = modificationItems[0].getAttribute();
    assertThat(modificationAttribute.getID()).isEqualTo("abc");
    assertThat(modificationAttribute.size()).isEqualTo(1);
    assertThat(modificationAttribute.get()).isEqualTo("123");
    assertThat(modificationItems[0].getModificationOp()).isEqualTo(DirContext.REMOVE_ATTRIBUTE);
}

@Test
public void testNoChangeMultiAttributeOrderDoesNotMatter() throws Exception {
    final Attributes fixtureAttrs = new BasicAttributes();
    Attribute multi = new BasicAttribute("abc");
    multi.add("123");
    multi.add("qwe");
    fixtureAttrs.put(multi);
    class TestableDirContextAdapter extends DirContextAdapter {
        public TestableDirContextAdapter() {
            super(fixtureAttrs, null);
            setUpdateMode(true);
        }
    }
    tested = new TestableDirContextAdapter();
    tested.setAttributeValues("abc", new String[] { "qwe", "123" });

    ModificationItem[] mods = tested.getModificationItems();
    assertThat(mods.length).isEqualTo(0);
    String[] modNames = tested.getNamesOfModifiedAttributes();
    assertThat(modNames.length).isEqualTo(0);
}

public void testToString() {
    log.setMethod("testToString()");
    String str;

    AttributeModificationException ex = new AttributeModificationException(
            "sample message");
    str = ex.toString();
    assertTrue(str.indexOf("sample message") >= 0);
    assertFalse(str.indexOf("sample id") >= 0);
    assertFalse(str.indexOf("sample value") >= 0);

    ModificationItem items[] = new ModificationItem[] { new ModificationItem(
            DirContext.ADD_ATTRIBUTE, new BasicAttribute("sample id",
                    "sample value")), };

    ex.setUnexecutedModifications(items);
    str = ex.toString();
    assertTrue(str.indexOf("sample message") >= 0);
    assertTrue(str.indexOf("sample id") >= 0);
    assertTrue(str.indexOf("sample value") >= 0);
}

@Test
public void testUpdateWithIdSpecified() throws NamingException {
    when(contextSourceMock.getReadOnlyContext()).thenReturn(dirContextMock);
    when(contextSourceMock.getReadWriteContext()).thenReturn(dirContextMock);
    LdapName expectedName = LdapUtils.newLdapName("ou=someOu");

    ModificationItem[] expectedModificationItems = new ModificationItem[0];
    DirContextOperations ctxMock = mock(DirContextOperations.class);
    when(ctxMock.getDn()).thenReturn(expectedName);
    when(ctxMock.isUpdateMode()).thenReturn(true);
    when(ctxMock.getModificationItems()).thenReturn(expectedModificationItems);

    Object expectedObject = new Object();
    when(odmMock.getId(expectedObject)).thenReturn(expectedName);
    when(odmMock.getCalculatedId(expectedObject)).thenReturn(null);

    when(dirContextMock.lookup(expectedName)).thenReturn(ctxMock);

    tested.update(expectedObject);

    verify(odmMock, never()).setId(expectedObject, expectedName);
    verify(odmMock).mapToLdapDataEntry(expectedObject, ctxMock);
    verify(dirContextMock).modifyAttributes(expectedName, expectedModificationItems);

    verify(dirContextMock, times(2)).close();
}

/**
 * Helper method for appending modification item(s) to a given list. At least one entry will be added if no attrValue is given.
 * @param list
 * @param attrId
 * @param attrValues If null then a null-value will be assumed. If more than one string is given, multiple modification items will be
 *          added.
 * @return
 */
protected void createAndAddModificationItems(final List<ModificationItem> list, final String attrId, final String... attrValues)
{
  if (attrValues == null) {
    list.add(createModificationItem(attrId, null));
    return;
  }
  boolean added = false;
  for (final String attrValue : attrValues) {
    if (StringUtils.isEmpty(attrValue) == true && added == true) {
      continue;
    }
    final String val = StringUtils.isEmpty(attrValue) == true ? null : attrValue;
    if (added == false) {
      list.add(createModificationItem(DirContext.REPLACE_ATTRIBUTE, attrId, val));
      added = true;
    } else {
      list.add(createModificationItem(DirContext.ADD_ATTRIBUTE, attrId, val));
    }
  }
}

@Test
public void testChangeAttribute() throws Exception {
    final Attributes fixtureAttrs = new BasicAttributes();
    fixtureAttrs.put(new BasicAttribute("abc", "123"));
    class TestableDirContextAdapter extends DirContextAdapter {
        public TestableDirContextAdapter() {
            super(fixtureAttrs, null);
            setUpdateMode(true);
        }
    }
    tested = new TestableDirContextAdapter();
    tested.setAttributeValue("abc", "234"); // change

    ModificationItem[] mods = tested.getModificationItems();
    assertThat(mods.length).isEqualTo(1);
    assertThat(mods[0].getModificationOp()).isEqualTo(DirContext.REPLACE_ATTRIBUTE);
    Attribute attr = mods[0].getAttribute();
    assertThat((String) attr.getID()).isEqualTo("abc");
    assertThat((String) attr.get()).isEqualTo("234");
}

public void modify(final DirContext ctx, final T obj, final List<ModificationItem> modificationItems) throws NamingException
{
  final Object id = getId(obj);
  // The dn is may-be changed, so find the original dn by id:
  final T origObject = findById(ctx, id, obj.getOrganizationalUnit());
  if (origObject == null) {
    throw new RuntimeException("Object with id "
        + id
        + " not found in search base '"
        + StringHelper.listToString(",", obj.getOrganizationalUnit())
        + "'. Can't modify the object: "
        + obj);
  }
  final String dn = origObject.getDn();
  log.info("Modify attributes of " + getObjectClass() + ": " + dn + ": " + getLogInfo(obj));
  final ModificationItem[] items = modificationItems.toArray(new ModificationItem[modificationItems.size()]);
  ctx.modifyAttributes(dn, items);
  // Don't move object.
  // if (obj.getDn() != null && StringUtils.equals(dn, obj.getDn()) == false) {
  // log.info("DN of object is changed from '" + dn + "' to '" + obj.getDn());
  // ctx.rename(dn, obj.getDn());
  // }
}

public void changePassword(final LdapUser user, final String oldPassword, final String newPassword)
{
  log.info("Change password for " + getObjectClass() + ": " + buildDn(null, user));
  final List<ModificationItem> modificationItems = new ArrayList<ModificationItem>();
  if (oldPassword != null) {
    modificationItems.add(new ModificationItem(DirContext.REMOVE_ATTRIBUTE, new BasicAttribute("userPassword", oldPassword)));
    modificationItems.add(new ModificationItem(DirContext.ADD_ATTRIBUTE, new BasicAttribute("userPassword", newPassword)));
  } else {
    modificationItems.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("userPassword", newPassword)));
  }
  if (isSambaAccountsConfigured() == true && user.getSambaSIDNumber() != null) {
    final String sambaNTPassword = SmbEncrypt.NTUNICODEHash(newPassword);
    modificationItems.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("sambaNTPassword", sambaNTPassword)));
  }
  // Perform the update
  modify(user, modificationItems);
}

@Test
public void testCommit() {
    ModificationItem[] expectedCompensatingItems = new ModificationItem[0];
    ModificationItem[] expectedActualItems = new ModificationItem[0];

    Name expectedDn = LdapUtils.newLdapName("cn=john doe");

    ModifyAttributesOperationExecutor tested = new ModifyAttributesOperationExecutor(ldapOperationsMock,
            expectedDn, expectedActualItems, expectedCompensatingItems);

    // No operation here
       verifyNoMoreInteractions(ldapOperationsMock);

    // Perform test
    tested.commit();
}

/**
 * Ajoute un ModificationItem à la liste <code>modificationItems</code>
 * Si la valeur <code>value</code> est null
 *  alors aucune modification n'est appliquée
 * Si la valeur est vide
 *  alors une suppression est appliqué
 * Sinon
 *  une modification est appliqué
 * 
 * @param modificationItems
 * @param attributeName
 * @param value
 */
public static void addMoficicationItemRemoveIfBlankElseReplace(List<ModificationItem> modificationItems, String attributeName, String value, String previousValue){
    if (value != null){
        if (StringUtils.isBlank(value)){
            if (StringUtils.isNotBlank(previousValue)){
                modificationItems.add(new ModificationItem(
                            DirContext.REMOVE_ATTRIBUTE, 
                            new BasicAttribute(attributeName)));
            }
            //Sinon, on ne fait rien: on veut remplacer du vide pas du vide...

        }
        else{
            modificationItems.add(new ModificationItem(
                    DirContext.REPLACE_ATTRIBUTE, 
                    new BasicAttribute(attributeName, value)));
        }
    }
}

@Test
public void testChangeMultiAttribute_RemoveTwoValues() throws Exception {
    final Attributes fixtureAttrs = new BasicAttributes();
    Attribute multi = new BasicAttribute("abc");
    multi.add("123");
    multi.add("qwe");
    multi.add("rty");
    fixtureAttrs.put(multi);
    class TestableDirContextAdapter extends DirContextAdapter {
        public TestableDirContextAdapter() {
            super(fixtureAttrs, null);
            setUpdateMode(true);
        }
    }
    tested = new TestableDirContextAdapter();
    assertThat(tested.isUpdateMode()).isTrue();
    tested.setAttributeValues("abc", new String[] { "123" });

    ModificationItem[] modificationItems = tested.getModificationItems();
    assertThat(modificationItems.length).isEqualTo(1);
    assertThat(modificationItems[0].getModificationOp()).isEqualTo(DirContext.REMOVE_ATTRIBUTE);
    assertThat(modificationItems[0].getAttribute().get(0)).isEqualTo("qwe");
    assertThat(modificationItems[0].getAttribute().get(1)).isEqualTo("rty");
}

@Override
public void unlock(final UserOrg user) {
    if (user.getIsolated() == null && user.getLockedBy() != null) {
        // Need to be unlocked
        final ModificationItem[] mods = new ModificationItem[1];
        mods[0] = new ModificationItem(DirContext.REMOVE_ATTRIBUTE, new BasicAttribute(lockedAttribute));
        template.modifyAttributes(org.springframework.ldap.support.LdapUtils.newLdapName(user.getDn()), mods);

        // Also clear the disabled state from cache
        user.setLocked(null);
        user.setLockedBy(null);
    }
}