Spring/spring-ldap
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

spring-ldap-odm patch, Jul 12 from Jasper

Browse Source
This commit is contained in:
Mattias Arthursson
2007-07-13 06:09:45 +00:00
parent c6ec91ddcd
commit 6a62bab775
22 changed files with 1101 additions and 618 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
spring-ldap-odm/build.xml
View File

@@ -19,7 +19,7 @@
<import file="${common.build.dir}/itest-targets.xml" />
<import file="${common.build.dir}/doc-targets.xml" />
<import file="${common.build.dir}/clover-targets.xml" />
<import file="${common.build.dir}/jdiff-targets.xml" />
<import file="${common.build.dir}/jdiff-targets.xml" />
<!-- extend common-build with source capability -->
<target name="build.prepare.make.config.dirs" depends="common-targets.build.prepare.make.config.dirs">
@@ -29,9 +29,10 @@
<!--
Overridden to create test report and run integration tests as well.
-->
<target name="tests" depends="tests-local,test-report,itests,itest-report" description="Runs all tests, first local then server (if any)" />
<target name="tests" depends="clover.init, tests-local,test-report,clover-report, itests,itest-report" description="Runs all tests, first local then server (if any)" />
<!--
<!--
Overridden only to have the errorproperty and failureproperty attributes
added to the junit task.
-->
@@ -42,7 +43,7 @@
we want to optionally run all tests and report on the whole
batch, then we need to set a failure property as in the server
tests. -->
<junit forkmode="perBatch" printsummary="yes" haltonfailure="no" haltonerror="no" dir="${basedir}" errorproperty="tests.failed" failureproperty="tests.failed">
<junit forkmode="perBatch" printsummary="yes" haltonfailure="no" haltonerror="no" dir="${basedir}" errorproperty="tests.failed" failureproperty="tests.failed" fork="true">
<jvmarg value="${unitvm}" />
<jvmarg value="-Djava.security.auth.login.config=${target.testclasses.dir}/auth.conf" />
<jvmarg value="${test.arguments}" />
@@ -64,7 +65,7 @@
</target>
<property name="target.testresults.html.dir" location="${target.testresults.dir}/html" />
<!-- Generate the unit test report -->
<target name="test-report" depends="build.prepare" description="Generate HTML report of unit test results">
<delete dir="${target.testresults.html.dir}" />

84
spring-ldap-odm/src/itest/java/conf/apacheDsContext.xml Normal file
View File

@@ -0,0 +1,84 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
This context automatically starts the Apache Directory Server
and sets up the test data
-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<!-- JNDI environment variable -->
<bean id="environment"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="properties">
<props>
<prop key="java.naming.security.authentication">
simple
</prop>
<prop key="java.naming.security.principal">
${userDn}
</prop>
<prop key="java.naming.security.credentials">
${password}
</prop>
</props>
</property>
</bean>
<!--
Note the non-standard port, in order to leave 389 unused, thus
making it easier for the integration tests requiring OpenLDAP.
-->
<bean id="configuration" class="org.apache.directory.server.configuration.MutableServerStartupConfiguration">
<property name="ldapPort" value="3900" />
<property name="contextPartitionConfigurations">
<set>
<ref bean="jaywayPartitionConfiguration"/>
</set>
</property>
</bean>
<bean id="jaywayPartitionConfiguration"
class="org.apache.directory.server.core.partition.impl.btree.MutableBTreePartitionConfiguration">
<property name="name" value="example" />
<property name="suffix" value="dc=example,dc=com" />
<property name="contextEntry">
<value>
objectClass: top
objectClass: domain
objectClass: extensibleObject
dc: example
</value>
</property>
</bean>
<bean id="configEnvHelper" class="org.springframework.ldap.ConfigEnvHelper">
<constructor-arg ref="environment" />
<constructor-arg ref="configuration" />
</bean>
<bean name="serverContext" class="javax.naming.InitialContext">
<constructor-arg>
<bean class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
<property name="targetObject" ref="configEnvHelper" />
<property name="propertyPath" value="env" />
</bean>
</constructor-arg>
</bean>
<bean name="ldapServerManager" class="org.springframework.ldap.LdapServerManager">
<property name="contextSource" ref="contextSource" />
</bean>
<!-- Custom editors required to launch ApacheDS -->
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="javax.naming.directory.Attributes">
<bean class="org.apache.directory.server.core.configuration.AttributesPropertyEditor"/>
</entry>
</map>
</property>
</bean>
</beans>

20
spring-ldap-odm/src/itest/java/conf/beans.xml
View File

@@ -2,12 +2,20 @@
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="contextSource" class="org.springframework.ldap.core.support.LdapContextSource">
<property name="url" value="ldap://localhost:10389"/>
<property name="base" value="dc=example,dc=com"/>
<property name="userName" value="cn=Directory Manager"/>
<property name="password" value="password"/>
</bean>
<import resource="classpath:/conf/apacheDsContext.xml"/>
<bean id="placeholderConfig"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:/conf/ldap.properties" />
</bean>
<bean id="contextSource" class="org.springframework.ldap.core.support.LdapContextSource" >
<property name="urls" value="${urls}" />
<property name="userDn" value="${userDn}" />
<property name="password" value="${password}" />
<property name="base" value="${base}" />
<property name="dirObjectFactory" value="org.springframework.ldap.core.support.DefaultDirObjectFactory" />
</bean>
<bean id="ldapTemplate" singleton="true" class="org.springframework.ldap.core.LdapTemplate">
<constructor-arg ref="contextSource"/>

4
spring-ldap-odm/src/itest/java/conf/ldap.properties Normal file
View File

@@ -0,0 +1,4 @@
urls=ldap://127.0.0.1:3900
userDn=uid=admin,ou=system
password=secret
base=dc=example,dc=com

50
spring-ldap-odm/src/itest/java/conf/log4j.xml Normal file
View File

@@ -0,0 +1,50 @@
<?xml version="1.0"?>
<!DOCTYPE log4j:configuration SYSTEM "http://logging.apache.org/log4j/docs/api/org/apache/log4j/xml/log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="console" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<!-- <param name="ConversionPattern" value="[%d{dd/MMM/yyy:HH:mm:ss:SS}] [%t] [%x] %-5p %c{1} - %m %n"/> -->
<param name="ConversionPattern" value="[%t] [%x] %-5p %c{1} - %m %n"/>
</layout>
</appender>
<appender name="file" class="org.apache.log4j.FileAppender">
<param name="file" value="odm.log"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="[%d{dd/MMM/yyy:HH:mm:ss:SS}] [%t] [%x] %-5p %c{1} - %m %n"/>
</layout>
</appender>
<logger name="org.springframework.beans">
<level value="warn"/>
<appender-ref ref="console"/>
</logger>
<logger name="org.springframework.context">
<level value="warn"/>
<appender-ref ref="console"/>
</logger>
<logger name="org.apache.directory">
<level value="error"/>
<appender-ref ref="console"/>
</logger>
<logger name="org.springframework.core">
<level value="warn"/>
<appender-ref ref="console"/>
</logger>
<logger name="org.springframework.ldap.core">
<level value="info"/>
<appender-ref ref="console"/>
</logger>
<logger name="org.springframework.ldap.odm">
<level value="debug"/>
<appender-ref ref="console"/>
</logger>
</log4j:configuration>

19
spring-ldap-odm/src/itest/java/conf/setup_data.ldif Normal file
View File

@@ -0,0 +1,19 @@
dn: ou=people,dc=example,dc=com
objectclass: top
objectclass: organizationalUnit
ou: people
dn: ou=roles,dc=example,dc=com
objectclass: top
objectclass: organizationalUnit
ou: roles
dn: cn=webUser,ou=roles,dc=example,dc=com
objectclass: top
objectclass: organizationalRole
cn: webUser
description: Everyday site visitor

9
spring-ldap-odm/src/itest/java/conf/teardown_data.ldif Normal file
View File

@@ -0,0 +1,9 @@
dn: ou=people,dc=example,dc=com
objectclass: top
objectclass: organizationalUnit
ou: people
dn: ou=roles,dc=example,dc=com
objectclass: top
objectclass: organizationalUnit
ou: roles

34
spring-ldap-odm/src/itest/java/org/springframework/ldap/AbstractLdapTemplateIntegrationTest.java Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright 2005-2007 the original author or authors.
*
* Licensed 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.springframework.ldap;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
public abstract class AbstractLdapTemplateIntegrationTest extends
AbstractDependencyInjectionSpringContextTests {
private LdapServerManager ldapServerManager;
protected void onSetUp() throws Exception {
super.onSetUp();
ldapServerManager.cleanAndSetup("setup_data.ldif");
}
public void setLdapServerManager(LdapServerManager ldapServerManager) {
this.ldapServerManager = ldapServerManager;
}
}

58
spring-ldap-odm/src/itest/java/org/springframework/ldap/ConfigEnvHelper.java Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2005-2007 the original author or authors.
*
* Licensed 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.springframework.ldap;
import java.io.File;
import java.util.Hashtable;
import javax.naming.Context;
import org.apache.directory.server.configuration.MutableServerStartupConfiguration;
import org.apache.directory.server.jndi.ServerContextFactory;
import org.springframework.beans.factory.InitializingBean;
/**
* Helper class to simplify Spring configuration of ApacheDS.
*
* @author Mattias Arthursson
*/
public class ConfigEnvHelper implements InitializingBean {
private final MutableServerStartupConfiguration configuration;
private final Hashtable initialEnv;
private final File workingDir = new File(System
.getProperty("java.io.tmpdir")
+ File.separator + "ldaptemplate_apacheds");
public ConfigEnvHelper(Hashtable initialEnv,
MutableServerStartupConfiguration configuration) {
this.initialEnv = initialEnv;
this.configuration = configuration;
}
public Hashtable getEnv() {
return initialEnv;
}
public void afterPropertiesSet() throws Exception {
initialEnv.put(Context.INITIAL_CONTEXT_FACTORY, ServerContextFactory.class.getName());
configuration.setWorkingDirectory(workingDir);
initialEnv.putAll(configuration.toJndiEnvironment());
}
}

126
spring-ldap-odm/src/itest/java/org/springframework/ldap/LdapServerManager.java Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright 2005-2007 the original author or authors.
*
* Licensed 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.springframework.ldap;
import java.util.Properties;
import javax.naming.Binding;
import javax.naming.Context;
import javax.naming.ContextNotEmptyException;
import javax.naming.InitialContext;
import javax.naming.Name;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.directory.server.core.configuration.ShutdownConfiguration;
import org.apache.directory.server.jndi.ServerContextFactory;
import org.apache.directory.server.protocol.shared.store.LdifFileLoader;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.support.DefaultDirObjectFactory;
/**
* Utility class to initialize the apache directory server for use in the
* integration tests.
*
* @author Mattias Arthursson
*
*/
public class LdapServerManager implements DisposableBean {
private static Log log = LogFactory.getLog(LdapServerManager.class);
private ContextSource contextSource;
public void setContextSource(ContextSource contextSource) {
this.contextSource = contextSource;
}
public void destroy() throws Exception {
Properties env = new Properties();
env.setProperty(Context.INITIAL_CONTEXT_FACTORY,
ServerContextFactory.class.getName());
env.setProperty(Context.SECURITY_AUTHENTICATION, "simple");
env.setProperty(Context.SECURITY_PRINCIPAL, "uid=admin,ou=system");
env.setProperty(Context.SECURITY_CREDENTIALS, "secret");
ShutdownConfiguration configuration = new ShutdownConfiguration();
env.putAll(configuration.toJndiEnvironment());
new InitialContext(env);
}
public void cleanAndSetup(String ldifFile) throws Exception {
DirContext ctx = contextSource.getReadWriteContext();
// First of all, make sure the database is empty.
Name startingPoint = null;
// Different test cases have different base paths. This means that the
// starting point will be different.
if (ctx.getEnvironment().get(
DefaultDirObjectFactory.JNDI_ENV_BASE_PATH_KEY) != null) {
startingPoint = DistinguishedName.EMPTY_PATH;
} else {
startingPoint = new DistinguishedName("dc=jayway,dc=se");
}
try {
log.info("Cleaning all present data.");
clearSubContexts(ctx, startingPoint);
// Load the ldif to the recently started server
log.info("Loading setup data");
LdifFileLoader loader = new LdifFileLoader(ctx, ldifFile);
loader.execute();
} finally {
ctx.close();
}
}
private void clearSubContexts(DirContext ctx, Name name)
throws NamingException {
NamingEnumeration enumeration = null;
try {
enumeration = ctx.listBindings(name);
while (enumeration.hasMore()) {
Binding element = (Binding) enumeration.next();
DistinguishedName childName = new DistinguishedName(element
.getName());
childName.prepend((DistinguishedName) name);
try {
ctx.destroySubcontext(childName);
} catch (ContextNotEmptyException e) {
clearSubContexts(ctx, childName);
ctx.destroySubcontext(childName);
}
}
} catch (NamingException e) {
e.printStackTrace();
} finally {
try {
enumeration.close();
} catch (Exception e) {
// Never mind this
}
}
}
}

611
spring-ldap-odm/src/itest/java/org/springframework/ldap/odm/contextmapping/AnnotatedClassContextMapperTest.java
View File

@@ -5,15 +5,8 @@
*/
package org.springframework.ldap.odm.contextmapping;
import java.util.Date;
import java.util.Map;
import javax.naming.Name;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.DirContextAdapter;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.odm.annotations.DirAttribute;
import org.springframework.ldap.odm.annotations.NamingAttribute;
import org.springframework.ldap.odm.annotations.NamingSuffix;
@@ -22,328 +15,380 @@ import org.springframework.ldap.odm.attributetypes.LdapTypeConverter;
import org.springframework.ldap.odm.attributetypes.ReferencedEntryEditorFactory;
import org.springframework.ldap.odm.contextmapping.exception.ContextMapperException;
import org.springframework.ldap.odm.entity.MockEntity;
import org.springframework.ldap.core.DirContextAdapter;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
import org.testng.Assert;
import org.testng.annotations.Test;
import javax.naming.Name;
import java.util.Date;
import java.util.Map;
public class AnnotatedClassContextMapperTest extends
AbstractDependencyInjectionSpringContextTests {
private static final Log LOGGER = LogFactory
.getLog(AnnotatedClassContextMapperTest.class);
AbstractDependencyInjectionSpringContextTests
{
private static final Log LOGGER = LogFactory
.getLog(AnnotatedClassContextMapperTest.class);
private LdapTypeConverter typeConverter;
private LdapTypeConverter typeConverter;
private ReferencedEntryEditorFactory refEditorFactory;
private ReferencedEntryEditorFactory refEditorFactory;
public void setRefEditorFactory(
ReferencedEntryEditorFactory refEditorFactory) {
this.refEditorFactory = refEditorFactory;
}
public void setRefEditorFactory(
ReferencedEntryEditorFactory refEditorFactory)
{
this.refEditorFactory = refEditorFactory;
}
public void setTypeConverter(LdapTypeConverter typeConverter) {
this.typeConverter = typeConverter;
}
public void setTypeConverter(LdapTypeConverter typeConverter)
{
this.typeConverter = typeConverter;
}
@Override
protected String[] getConfigLocations() {
return new String[] { "conf/beans.xml" };
}
@Override
protected String[] getConfigLocations()
{
return new String[]{"conf/beans.xml"};
}
public void testMapsDirectoryAttributesToBeanProperties() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
ContextMap contextMap = contextMapper.getContextMap();
Assert.assertEquals("cn", contextMap.attributeNameFor("Name"),
"Name mapping not as expected");
Assert.assertEquals("mail", contextMap.attributeNameFor("Mail"),
"Mail mapping not as expected");
Assert.assertEquals("addr", contextMap.attributeNameFor("Address"),
"Address mapping not as expected");
Assert.assertEquals("userpassword", contextMap
.attributeNameFor("Password"),
"Password mapping not as expected");
Assert.assertEquals("desc", contextMap
.attributeNameFor("Description"),
"Description mapping not as expected");
} catch (ContextMapperException e) {
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
public void testMapsDirectoryAttributesToBeanProperties()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
ContextMap contextMap = contextMapper.getContextMap();
Assert.assertEquals("cn", contextMap.attributeNameFor("Name"),
"Name mapping not as expected");
Assert.assertEquals("mail", contextMap.attributeNameFor("Mail"),
"Mail mapping not as expected");
Assert.assertEquals("addr", contextMap.attributeNameFor("Address"),
"Address mapping not as expected");
Assert.assertEquals("userpassword", contextMap
.attributeNameFor("Password"),
"Password mapping not as expected");
Assert.assertEquals("desc", contextMap
.attributeNameFor("Description"),
"Description mapping not as expected");
}
catch (ContextMapperException e)
{
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
public void testReturnsCorrectNamingAttribute() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
Assert.assertEquals("cn", contextMapper.getNamingAttribute(),
"Context mapper naming attribute not as expected");
public void testReturnsCorrectNamingAttribute()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
Assert.assertEquals("cn", contextMapper.getNamingAttribute(),
"Context mapper naming attribute not as expected");
} catch (ContextMapperException e) {
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
}
catch (ContextMapperException e)
{
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
public void testReturnsCorrectObjectClasses() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
Assert.assertEquals(new String[] { "top", "person",
"organizationalPerson", "inetorgperson" }, contextMapper
.getObjectClasses(),
"Context mapper naming attribute not as expected");
public void testReturnsCorrectObjectClasses()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
Assert.assertEquals(new String[]{"top", "person",
"organizationalPerson", "inetorgperson"}, contextMapper
.getObjectClasses(),
"Context mapper naming attribute not as expected");
} catch (ContextMapperException e) {
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage());
}
}
}
catch (ContextMapperException e)
{
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage());
}
}
public void testBuildDn() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
MockEntity entity = new MockEntity();
entity.setName("Mr Bean");
entity.setAddress("Somewhere in england");
entity.setDescription(new String[] { "The quick brown fox jumped",
"over the lazy dog" });
Name dn = contextMapper.buildDn(entity);
Assert.assertEquals("cn=Mr Bean, ou=people, dc=example, dc=com", dn
.toString(), "dn not as expected");
public void testBuildDn()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
MockEntity entity = new MockEntity();
entity.setName("Mr Bean");
entity.setAddress("Somewhere in england");
entity.setDescription(new String[]{"The quick brown fox jumped",
"over the lazy dog"});
Name dn = contextMapper.buildDn(entity);
Assert.assertEquals("cn=Mr Bean, ou=people, dc=example, dc=com", dn
.toString(), "dn not as expected");
} catch (ContextMapperException e) {
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage());
}
}
}
catch (ContextMapperException e)
{
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage());
}
}
public void testMapToContext() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
MockEntity entity = new MockEntity();
entity.setName("Mr Bean");
entity.setMail("bean@bean.com");
entity.setAddress("Somewhere in england");
entity.setPassword("fred".getBytes());
entity.setDescription(new String[] { "The quick brown fox jumped",
"over the lazy dog" });
entity.setAcceptEmails(false);
entity.setResetLogin(new Date(1L));
entity.setCreator(new DistinguishedName(
"uid=amAdmin,ou=people,dc=myretsu,dc=com"));
entity.setFailedLogins(3);
DirContextAdapter ctxAdapter = new DirContextAdapter();
contextMapper.mapToContext(entity, ctxAdapter);
public void testMapToContext()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
MockEntity entity = new MockEntity();
entity.setName("Mr Bean");
entity.setMail("bean@bean.com");
entity.setAddress("Somewhere in england");
entity.setPassword("fred".getBytes());
entity.setDescription(new String[]{"The quick brown fox jumped",
"over the lazy dog"});
entity.setAcceptEmails(false);
entity.setResetLogin(new Date(1L));
entity.setCreator(new DistinguishedName(
"uid=amAdmin,ou=people,dc=myretsu,dc=com"));
entity.setFailedLogins(3);
DirContextAdapter ctxAdapter = new DirContextAdapter();
contextMapper.mapToContext(entity, ctxAdapter);
Assert.assertEquals("Mr Bean", ctxAdapter.getStringAttribute("cn"),
"Name mapping not as expected");
Assert
.assertEquals("bean@bean.com", ctxAdapter
.getStringAttribute("mail"),
"Mail mapping not as expected");
Assert.assertEquals("Somewhere in england", ctxAdapter
.getObjectAttribute("addr"),
"Address mapping not as expected");
Assert.assertEquals("fred", new String((byte[]) ctxAdapter
.getObjectAttribute("userpassword")),
"Password mapping not as expected");
Assert.assertEquals("The quick brown fox jumped", ctxAdapter
.getStringAttributes("desc")[0],
"Description mapping not as expected");
Assert.assertEquals("false", ctxAdapter
.getStringAttribute("acceptemails"),
"AcceptEmails mapping not as expected");
Assert.assertEquals("19700101100000.1", ctxAdapter
.getStringAttribute("loginresettime"),
"ResetLogin mapping not as expected");
Assert.assertEquals("3", ctxAdapter
.getStringAttribute("failedlogins"),
"FailedLogins mapping not as expected");
Assert.assertEquals("uid=amAdmin, ou=people, dc=myretsu, dc=com",
ctxAdapter.getStringAttribute("creatorname"),
"Creator mapping not as expected");
} catch (ContextMapperException e) {
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
Assert.assertEquals("Mr Bean", ctxAdapter.getStringAttribute("cn"),
"Name mapping not as expected");
Assert
.assertEquals("bean@bean.com", ctxAdapter
.getStringAttribute("mail"),
"Mail mapping not as expected");
Assert.assertEquals("Somewhere in england", ctxAdapter
.getObjectAttribute("addr"),
"Address mapping not as expected");
Assert.assertEquals("fred", new String((byte[]) ctxAdapter
.getObjectAttribute("userpassword")),
"Password mapping not as expected");
Assert.assertEquals("The quick brown fox jumped", ctxAdapter
.getStringAttributes("desc")[0],
"Description mapping not as expected");
Assert.assertEquals("false", ctxAdapter
.getStringAttribute("acceptemails"),
"AcceptEmails mapping not as expected");
Assert.assertEquals("19700101100000.1", ctxAdapter
.getStringAttribute("loginresettime"),
"ResetLogin mapping not as expected");
Assert.assertEquals("3", ctxAdapter
.getStringAttribute("failedlogins"),
"FailedLogins mapping not as expected");
Assert.assertEquals("uid=amAdmin, ou=people, dc=myretsu, dc=com",
ctxAdapter.getStringAttribute("creatorname"),
"Creator mapping not as expected");
}
catch (ContextMapperException e)
{
LOGGER.debug(e.getMessage());
Assert.fail(e.getMessage(), e);
}
}
public void testMapFromContext() throws ContextMapperException {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
DirContextAdapter ctxAdapter = new DirContextAdapter();
ctxAdapter.setAttributeValue("cn", "Mr Bean");
ctxAdapter.setAttributeValue("mail", "bean@bean.com");
ctxAdapter.setAttributeValue("addr", "Somewhere in england");
ctxAdapter.setAttributeValue("userpassword", "fred".getBytes());
ctxAdapter
.setAttributeValues("desc", new String[] { "elem1", "elem2" });
ctxAdapter.setAttributeValue("userpassword", "fred".getBytes());
ctxAdapter.setAttributeValue("acceptemails", "true");
ctxAdapter.setAttributeValue("loginresettime", "19700101100000.1");
ctxAdapter.setAttributeValue("failedlogins", "3");
ctxAdapter.setAttributeValue("creatorname",
"uid=amAdmin,ou=people,dc=myretsu,dc=com");
public void testMapFromContext() throws ContextMapperException
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockEntity.class, typeConverter, refEditorFactory);
DirContextAdapter ctxAdapter = new DirContextAdapter();
ctxAdapter.setAttributeValue("cn", "Mr Bean");
ctxAdapter.setAttributeValue("mail", "bean@bean.com");
ctxAdapter.setAttributeValue("addr", "Somewhere in england");
ctxAdapter.setAttributeValue("userpassword", "fred".getBytes());
ctxAdapter
.setAttributeValues("desc", new String[]{"elem1", "elem2"});
ctxAdapter.setAttributeValue("userpassword", "fred".getBytes());
ctxAdapter.setAttributeValue("acceptemails", "true");
ctxAdapter.setAttributeValue("loginresettime", "19700101100000.1");
ctxAdapter.setAttributeValue("failedlogins", "3");
ctxAdapter.setAttributeValue("creatorname",
"uid=amAdmin,ou=people,dc=myretsu,dc=com");
MockEntity entity = (MockEntity) contextMapper
.mapFromContext(ctxAdapter);
Assert.assertEquals(entity.getMail(), "bean@bean.com",
"The mocked entity should match what has been mapped");
Assert.assertEquals("Mr Bean", entity.getName(),
"Name mapping not as expected");
Assert.assertEquals(entity.getMail(), "bean@bean.com",
"Mail mapping not as expected");
Assert.assertEquals(entity.getAddress(), "Somewhere in england",
"Address mapping not as expected");
Assert.assertEquals("fred", new String(entity.getPassword()),
"Password mapping not as expected");
Assert.assertEquals("elem1", entity.getDescription()[0],
"Description mapping not as expected");
Assert.assertEquals(Boolean.TRUE, entity.getAcceptEmails(),
"AcceptEmails mapping not as expected");
Assert.assertEquals(new Date(1L), entity.getResetLogin(),
"ResetLogin mapping not as expected");
Assert.assertEquals(new Integer(3), entity.getFailedLogins(),
"FailedLogin mapping not as expected");
Assert.assertEquals(new DistinguishedName(
"uid=amAdmin,ou=people,dc=myretsu,dc=com"),
entity.getCreator(), "Creator mapping not as expected");
MockEntity entity = (MockEntity) contextMapper
.mapFromContext(ctxAdapter);
Assert.assertEquals(entity.getMail(), "bean@bean.com",
"The mocked entity should match what has been mapped");
Assert.assertEquals("Mr Bean", entity.getName(),
"Name mapping not as expected");
Assert.assertEquals(entity.getMail(), "bean@bean.com",
"Mail mapping not as expected");
Assert.assertEquals(entity.getAddress(), "Somewhere in england",
"Address mapping not as expected");
Assert.assertEquals("fred", new String(entity.getPassword()),
"Password mapping not as expected");
Assert.assertEquals("elem1", entity.getDescription()[0],
"Description mapping not as expected");
Assert.assertEquals(Boolean.TRUE, entity.getAcceptEmails(),
"AcceptEmails mapping not as expected");
Assert.assertEquals(new Date(1L), entity.getResetLogin(),
"ResetLogin mapping not as expected");
Assert.assertEquals(new Integer(3), entity.getFailedLogins(),
"FailedLogin mapping not as expected");
Assert.assertEquals(new DistinguishedName(
"uid=amAdmin,ou=people,dc=myretsu,dc=com"),
entity.getCreator(), "Creator mapping not as expected");
}
}
@Test(groups = { "AnnotatedClassContextMapper" }, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenNamingSuffixHasSyntaxError()
throws ContextMapperException {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelNamingSuffixSyntaxError.class, typeConverter,
refEditorFactory);
Assert
.fail("AnnotatedClassContextMapper should throw an exception when naming path annotation syntax is "
+ "incorrect.");
}
@Test(groups = {"AnnotatedClassContextMapper"}, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenNamingSuffixHasSyntaxError()
throws ContextMapperException
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelNamingSuffixSyntaxError.class, typeConverter,
refEditorFactory);
Assert
.fail("AnnotatedClassContextMapper should throw an exception when naming path annotation syntax is "
+ "incorrect.");
}
@Test(groups = { "AnnotatedClassContextMapper" }, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenNamingSuffixNotInSeparateElements()
throws ContextMapperException {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelNamingSuffixNotInSeparateElements.class,
typeConverter, refEditorFactory);
Assert
.fail("AnnotatedClassContextMapper should throw an exception when naming path annotation syntax is "
+ "incorrect.");
}
@Test(groups = {"AnnotatedClassContextMapper"}, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenNamingSuffixNotInSeparateElements()
throws ContextMapperException
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelNamingSuffixNotInSeparateElements.class,
typeConverter, refEditorFactory);
Assert
.fail("AnnotatedClassContextMapper should throw an exception when naming path annotation syntax is "
+ "incorrect.");
}
@Test(groups = { "AnnotatedClassContextMapper" }, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenModelObjectMissingGetterOrSetter()
throws ContextMapperException {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelMissingSetter.class, typeConverter, refEditorFactory);
Assert.fail("Should've thrown exception due to missing getter/setter");
}
@Test(groups = {"AnnotatedClassContextMapper"}, expectedExceptions = ContextMapperException.class)
public void throwsExceptionWhenModelObjectMissingGetterOrSetter()
throws ContextMapperException
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelMissingSetter.class, typeConverter, refEditorFactory);
Assert.fail("Should've thrown exception due to missing getter/setter");
}
@Test(groups = { "AnnotatedClassContextMapper" })
public void throwsExceptionWhenBeanPropertyNotAValidTranslationType() {
try {
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelInvalidTranslationType.class, typeConverter,
refEditorFactory);
Assert
.fail("Should've thrown exception due to missing getter/setter");
} catch (ContextMapperException e) {
Assert
.assertTrue(e
.getMessage()
.contains(
"MockModelInvalidTranslationType.getMap() has invalid return type"));
}
@Test(groups = {"AnnotatedClassContextMapper"})
public void throwsExceptionWhenBeanPropertyNotAValidTranslationType()
{
try
{
AnnotatedClassContextMapper contextMapper = new AnnotatedClassContextMapper(
MockModelInvalidTranslationType.class, typeConverter,
refEditorFactory);
Assert
.fail("Should've thrown exception due to missing getter/setter");
}
catch (ContextMapperException e)
{
Assert
.assertTrue(e
.getMessage()
.contains(
"MockModelInvalidTranslationType.getMap() has invalid return type"));
}
}
}
@NamingAttribute("cn")
@NamingSuffix( { "ou=people", "dc=example", "dc=com" })
@ObjectClasses( { "top", "person", "organizationalPerson", "inetorgperson" })
public class MockModelMissingSetter {
@DirAttribute("cn")
private String name;
@NamingAttribute("cn")
@NamingSuffix({"ou=people", "dc=example", "dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
public class MockModelMissingSetter
{
@DirAttribute("cn")
private String name;
@DirAttribute("addr")
private String address;
@DirAttribute("addr")
private String address;
@DirAttribute("mail")
private String mail;
@DirAttribute("mail")
private String mail;
public String getName() {
return name;
}
public String getName()
{
return name;
}
public String getAddress() {
return address;
}
public String getAddress()
{
return address;
}
public String getMail() {
return mail;
}
public String getMail()
{
return mail;
}
public void setName(String name) {
this.name = name;
}
public void setName(String name)
{
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
}
public void setAddress(String address)
{
this.address = address;
}
}
@NamingAttribute("cn")
@NamingSuffix( { "ou=people", "dc=example", "dc=com" })
@ObjectClasses( { "top", "person", "organizationalPerson", "inetorgperson" })
public class MockModelBadMethodName {
@NamingAttribute("cn")
@NamingSuffix({"ou=people", "dc=example", "dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
public class MockModelBadMethodName
{
@DirAttribute("cn")
private String name;
@DirAttribute("cn")
private String name;
@DirAttribute("addr")
private String address;
@DirAttribute("addr")
private String address;
public String zzzName() {
return name;
}
public String zzzName()
{
return name;
}
public String getAddress() {
return address;
}
}
public String getAddress()
{
return address;
}
}
@NamingAttribute("cn")
@NamingSuffix( { "ou=people,dc=example ,dc=com" })
@ObjectClasses( { "top", "person", "organizationalPerson", "inetorgperson" })
public class MockModelNamingSuffixNotInSeparateElements {
}
@NamingAttribute("cn")
@NamingSuffix({"ou=people,dc=example ,dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
public class MockModelNamingSuffixNotInSeparateElements
{
}
@NamingAttribute("cn")
@NamingSuffix( { "ou=people", "dc<example", "dc=com" })
@ObjectClasses( { "top", "person", "organizationalPerson", "inetorgperson" })
public class MockModelNamingSuffixSyntaxError {
@NamingAttribute("cn")
@NamingSuffix({"ou=people", "dc<example", "dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
public class MockModelNamingSuffixSyntaxError
{
}
}
@NamingAttribute("cn")
@NamingSuffix( { "ou=people", "dc=example", "dc=com" })
@ObjectClasses( { "top", "person", "organizationalPerson", "inetorgperson" })
public class MockModelInvalidTranslationType {
@DirAttribute("fred")
private Map map;
@NamingAttribute("cn")
@NamingSuffix({"ou=people", "dc=example", "dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
public class MockModelInvalidTranslationType
{
@DirAttribute("fred")
private Map map;
public Map getMap() {
return map;
}
public Map getMap()
{
return map;
}
public void setMap(Map map) {
this.map = map;
}
public void setMap(Map map)
{
this.map = map;
}
}
}
}

110
spring-ldap-odm/src/itest/java/org/springframework/ldap/odm/dao/LdapDaoTest.java
View File

@@ -5,42 +5,44 @@
*/
package org.springframework.ldap.odm.dao;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.lang.ArrayUtils;
import org.springframework.ldap.AbstractLdapTemplateIntegrationTest;
import org.springframework.ldap.NameAlreadyBoundException;
import org.springframework.ldap.NameNotFoundException;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.odm.dao.exception.DataIntegrityViolationException;
import org.springframework.ldap.odm.dao.exception.EntryNotFoundException;
import org.springframework.ldap.odm.entity.TestPerson;
import org.springframework.ldap.odm.entity.TestRole;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.List;
public class LdapDaoTest
public class LdapDaoTest extends AbstractLdapTemplateIntegrationTest
{
protected static final Log LOGGER = LogFactory.getLog(LdapDaoTest.class);
protected LdapDao ldapDao;
private ClassPathXmlApplicationContext applicationContext;
private TestPerson testPerson;
private TestRole validRole;
@BeforeClass(alwaysRun = true)
public void initTestClass()
protected String[] getConfigLocations()
{
LOGGER.debug("********************INIT TEST CLASS**************************");
applicationContext = new ClassPathXmlApplicationContext("beans.xml");
ldapDao = (LdapDao) applicationContext.getBean("ldapDao");
return new String[]{"beans.xml"};
}
protected void onSetUp() throws Exception
{
super.onSetUp();
createPerMethodConsumer();
}
public void setLdapDao(LdapDao ldapDao)
{
this.ldapDao = ldapDao;
}
@BeforeMethod(alwaysRun = true)
public void createPerMethodConsumer()
{
LOGGER.debug("********************CREATE PER METHOD CONSUMER**************************");
@@ -53,18 +55,7 @@ public class LdapDaoTest
testPerson.setPassword("test1234".getBytes());
}
@BeforeClass(alwaysRun = true)
public void createValidRole()
{
LOGGER.debug("********************CREATE VALID ROLE**************************");
validRole = new TestRole();
validRole.setRoleName("webUser");
validRole.setDescription("A valid role");
}
@Test(groups = "LdapDao")
public void createEntity()
public void testCreateEntity()
{
try
{
@@ -76,8 +67,8 @@ public class LdapDaoTest
}
}
@Test(groups = "LdapDao")
public void createOrUpdateEntity()
public void testCreateOrUpdateEntity()
{
try
{
@@ -91,8 +82,7 @@ public class LdapDaoTest
}
@Test(groups = "LdapDao")
public void findByNamingAttribute()
public void testFindByNamingAttribute()
{
ldapDao.create(testPerson);
TestPerson retrieved = (TestPerson) ldapDao.findByNamingAttribute(testPerson.getIdentifier(), TestPerson.class);
@@ -100,18 +90,20 @@ public class LdapDaoTest
Assert.assertNotNull(retrieved, "Should've found the created entity.");
}
@Test(groups = "LdapDao")
public void findRoles()
public void testLoadsReferencedEntities()
{
TestRole webUser = (TestRole) ldapDao.findByNamingAttribute("webUser", TestRole.class);
ldapDao.create(testPerson);
validRole.setMembers(new TestPerson[]{testPerson});
ldapDao.createOrUpdate(validRole);
TestRole role = (TestRole) ldapDao.findByNamingAttribute("webUser", TestRole.class);
LOGGER.debug(role);
webUser.setMembers(new TestPerson[]{testPerson});
ldapDao.update(webUser);
TestRole updated = (TestRole) ldapDao.findByNamingAttribute("webUser", TestRole.class);
LOGGER.debug(updated);
Assert.assertTrue(ArrayUtils.contains(updated.getMembers(), testPerson));
}
@Test(groups = "LdapDao")
public void findByDn()
public void testFindByDn()
{
ldapDao.create(testPerson);
DistinguishedName dn = new DistinguishedName("uid=" + testPerson.getIdentifier() + ",ou=people");
@@ -121,8 +113,7 @@ public class LdapDaoTest
}
@Test(groups = "LdapDao")
public void createEntityThrowsExceptionWhenNameAlreadyBound()
public void testCreateEntityThrowsExceptionWhenNameAlreadyBound()
{
try
{
@@ -132,23 +123,20 @@ public class LdapDaoTest
}
catch (Exception expected)
{
Assert.assertTrue(expected instanceof DataIntegrityViolationException, "Exception type doesn't match expected. ( got: "
+ expected.getMessage());
Assert.assertTrue(expected.getMessage().contains("Name already bound"),
"Exception message doesn't match expected.");
Assert.assertTrue(expected instanceof NameAlreadyBoundException,
"Exception type doesn't match expected. ( got: "
+ expected.getMessage());
}
}
@Test(groups = "LdapDao")
public void findAll()
public void testFindAll()
{
ldapDao.create(testPerson);
List results = ldapDao.findAll(TestPerson.class);
Assert.assertTrue(results.size() > 0);
}
@Test(groups = "LdapDao")
public void filterByBeanProperty()
public void testFilterByBeanProperty()
{
ldapDao.create(testPerson);
List results = ldapDao.filterByBeanProperty(testPerson.getEmailAddress(), "EmailAddress", TestPerson.class);
@@ -156,9 +144,7 @@ public class LdapDaoTest
Assert.assertTrue(results.size() > 0, "Filter should return collection containing more than one result. ");
}
@Test(groups = "LdapDao")
public void updateEntity()
public void testUpdateEntity()
{
try
{
@@ -176,9 +162,7 @@ public class LdapDaoTest
}
}
@Test(groups = "LdapDao")
public void updateEntityThrowsExceptionWhenNameNotBound()
public void testUpdateEntityThrowsExceptionWhenNameNotBound()
{
try
{
@@ -187,15 +171,13 @@ public class LdapDaoTest
ldapDao.update(testPerson);
Assert.fail("Should've failed since the entry doesn't exist");
}
catch (EntryNotFoundException e)
catch (Exception e)
{
Assert.assertTrue(e instanceof EntryNotFoundException);
Assert.assertTrue(e.getMessage().contains("Entry not found"), "Error message not as expected.");
Assert.assertTrue(e instanceof NameNotFoundException);
}
}
@Test(groups = "LdapDao")
public void deleteEntity()
public void testDeleteEntity()
{
ldapDao.create(testPerson);
LOGGER.debug(testPerson);

4
spring-ldap-odm/src/itest/java/org/springframework/ldap/odm/entity/MockEntity.java
View File

@@ -5,14 +5,14 @@
*/
package org.springframework.ldap.odm.entity;
import java.util.Date;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.odm.annotations.DirAttribute;
import org.springframework.ldap.odm.annotations.NamingAttribute;
import org.springframework.ldap.odm.annotations.NamingSuffix;
import org.springframework.ldap.odm.annotations.ObjectClasses;
import java.util.Date;
@NamingAttribute("cn")
@NamingSuffix({"ou = people", "dc = example", "dc=com"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})

8
spring-ldap-odm/src/itest/java/org/springframework/ldap/odm/entity/TestPerson.java
View File

@@ -9,13 +9,14 @@ import org.springframework.ldap.odm.annotations.DirAttribute;
import org.springframework.ldap.odm.annotations.NamingAttribute;
import org.springframework.ldap.odm.annotations.NamingSuffix;
import org.springframework.ldap.odm.annotations.ObjectClasses;
import org.apache.commons.lang.builder.EqualsBuilder;
import com.thoughtworks.xstream.XStream;
@NamingAttribute("uid")
@NamingSuffix({"ou=people"})
@ObjectClasses({"top", "person", "organizationalPerson", "inetorgperson"})
@ObjectClasses({"person", "organizationalPerson", "inetorgperson"})
public class TestPerson
{
/*********************************** Directory mapped fields ************************************/
@@ -106,5 +107,10 @@ public class TestPerson
return "\n" + xStream.toXML(this);
}
public boolean equals(Object o)
{
return EqualsBuilder.reflectionEquals(this, o);
}
}

10
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/attributetypes/LdapTypeConverter.java
View File

@@ -5,15 +5,15 @@
*/
package org.springframework.ldap.odm.attributetypes;
import org.springframework.beans.SimpleTypeConverter;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.ldap.core.DistinguishedName;
import javax.naming.ldap.LdapName;
import java.beans.PropertyEditor;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.naming.ldap.LdapName;
import org.springframework.beans.SimpleTypeConverter;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.ldap.core.DistinguishedName;
public class LdapTypeConverter extends SimpleTypeConverter
{

7
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/attributetypes/NameEditor.java
View File

@@ -5,12 +5,11 @@
*/
package org.springframework.ldap.odm.attributetypes;
import java.beans.PropertyEditorSupport;
import javax.naming.ldap.LdapName;
import org.springframework.ldap.core.DistinguishedName;
import java.beans.PropertyEditorSupport;
import javax.naming.ldap.LdapName;
public class NameEditor extends PropertyEditorSupport
{
private Class conversionClass;

11
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/attributetypes/ReferencedEntryEditor.java
View File

@@ -5,17 +5,16 @@
*/
package org.springframework.ldap.odm.attributetypes;
import java.beans.PropertyEditorSupport;
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.odm.contextmapping.AnnotatedClassContextMapper;
import org.springframework.ldap.odm.contextmapping.exception.ContextMapperException;
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
import java.beans.PropertyEditorSupport;
public class ReferencedEntryEditor extends PropertyEditorSupport
{
{
private LdapTemplate ldapTemplate;
private AnnotatedClassContextMapper contextMapper;

3
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/attributetypes/ReferencedEntryEditorFactory.java
View File

@@ -10,11 +10,12 @@ import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.odm.attributetypes.exception.ReferencedEntryEditorCreationException;
import org.springframework.ldap.odm.contextmapping.AnnotatedClassContextMapper;
import org.springframework.ldap.odm.contextmapping.ContextMapperFactory;
import org.springframework.ldap.odm.contextmapping.exception.ContextMapperException;
import org.springframework.ldap.core.LdapTemplate;
public class ReferencedEntryEditorFactory
{

4
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/attributetypes/ValidConversionType.java
View File

@@ -5,11 +5,11 @@
*/
package org.springframework.ldap.odm.attributetypes;
import java.util.Date;
import org.springframework.ldap.core.DistinguishedName;
import javax.naming.ldap.LdapName;
import java.util.Date;
import org.springframework.ldap.core.DistinguishedName;
/* Should be able to support any of Spring's conversion types. Add a test case if you add one */
public enum ValidConversionType

15
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/contextmapping/AnnotatedClassContextMapper.java
View File

@@ -5,14 +5,6 @@
*/
package org.springframework.ldap.odm.contextmapping;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import javax.naming.Name;
import javax.naming.directory.Attribute;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.TypeMismatchException;
@@ -31,6 +23,13 @@ import org.springframework.ldap.odm.attributetypes.exception.ReferencedEntryEdit
import org.springframework.ldap.odm.contextmapping.exception.ContextMapperException;
import org.springframework.util.StringUtils;
import javax.naming.Name;
import javax.naming.directory.Attribute;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class AnnotatedClassContextMapper implements ContextMapper, ContextAssembler
{
private static final Log LOGGER = LogFactory.getLog(AnnotatedClassContextMapper.class);

16
spring-ldap-odm/src/main/java/org/springframework/ldap/odm/dao/LdapDaoImpl.java
View File

@@ -5,21 +5,19 @@
*/
package org.springframework.ldap.odm.dao;
import java.util.List;
import javax.naming.Name;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.DirContextAdapter;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.odm.contextmapping.AnnotatedClassContextMapper;
import org.springframework.ldap.odm.contextmapping.ContextMapperFactory;
import org.springframework.ldap.odm.contextmapping.exception.ContextMapperException;
import org.springframework.ldap.odm.dao.exception.DaoException;
import org.springframework.ldap.odm.dao.exception.DataIntegrityViolationException;
import org.springframework.ldap.odm.dao.exception.EntryNotFoundException;
import javax.naming.Name;
import java.util.List;
public class LdapDaoImpl implements LdapDao
{
@@ -62,12 +60,6 @@ public class LdapDaoImpl implements LdapDao
ctxMapper.mapToContext(dirObject, contextAdapter);
ldapTemplate.modifyAttributes(dn, contextAdapter.getModificationItems());
}
catch (org.springframework.ldap.NameNotFoundException e)
{
//We need to rethrow a serializable exception if we are going to invoke
//this as a remote service.
throw new EntryNotFoundException(e.getMessage());
}
catch (ContextMapperException e)
{
throw new DaoException(e.getMessage(), e);

505
spring-ldap-odm/src/test/java/org/springframework/ldap/odm/attributetypes/LdapTypeConverterTest.java
View File

@@ -5,260 +5,327 @@
*/
package org.springframework.ldap.odm.attributetypes;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
import junit.framework.TestCase;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.TypeMismatchException;
import org.springframework.ldap.core.DistinguishedName;
import org.testng.Assert;
public class LdapTypeConverterTest extends TestCase {
private static final Log LOGGER = LogFactory
.getLog(LdapTypeConverterTest.class);
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
private LdapTypeConverter typeConverter;
public class LdapTypeConverterTest extends TestCase
{
private static final Log LOGGER = LogFactory.getLog(LdapTypeConverterTest.class);
@Override
protected void setUp() throws Exception {
super.setUp();
typeConverter = new LdapTypeConverter();
}
private LdapTypeConverter typeConverter;
public void testConvertToByteArray() {
byte[] objectToTranslate = "fred".getBytes();
@Override
protected void setUp() throws Exception
{
super.setUp();
typeConverter = new LdapTypeConverter();
}
try {
byte[] translated = (byte[]) typeConverter.convertIfNecessary(
objectToTranslate, byte[].class);
Assert.assertTrue(Arrays.equals(objectToTranslate, translated),
"byte[] attributes should pass through unchanged.");
} catch (TypeMismatchException e) {
Assert
.fail(
"Unexpected exception: byte[] attributes should pass through unchanged.",
e);
}
}
public void testConvertToByteArray()
{
byte[] objectToTranslate = "fred".getBytes();
public void testConvertToBoolean() {
String objectToTranslate = "true";
try {
Object translated = typeConverter.convertIfNecessary(
objectToTranslate, Boolean.class);
Assert
.assertEquals(true, translated,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
try
{
byte[] translated = (byte[]) typeConverter.convertIfNecessary(
objectToTranslate, byte[].class);
Assert.assertTrue(Arrays.equals(objectToTranslate, translated),
"byte[] attributes should pass through unchanged.");
}
catch (TypeMismatchException e)
{
Assert
.fail(
"Unexpected exception: byte[] attributes should pass through unchanged.",
e);
}
}
public void testConvertFromBoolean() {
boolean objectToTranslate = false;
try {
Object translated = typeConverter.getAsText(objectToTranslate);
Assert.assertEquals(translated, "false",
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToBoolean()
{
String objectToTranslate = "true";
try
{
Object translated = typeConverter.convertIfNecessary(
objectToTranslate, Boolean.class);
Assert
.assertEquals(true, translated,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToString() {
String objectToTranslate = "onetwothree";
try {
Object translated = typeConverter.convertIfNecessary(
objectToTranslate, String.class);
Assert.assertEquals("onetwothree", translated,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertFromBoolean()
{
boolean objectToTranslate = false;
try
{
Object translated = typeConverter.getAsText(objectToTranslate);
Assert.assertEquals(translated, "false",
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToStringArray() {
String object1 = "onetwothree";
String object2 = "fourfivesix";
String object3 = "seveneightnine";
Object objectToTranslate = new String[] { object1, object2, object3 };
public void testConvertToString()
{
String objectToTranslate = "onetwothree";
try
{
Object translated = typeConverter.convertIfNecessary(
objectToTranslate, String.class);
Assert.assertEquals("onetwothree", translated,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, String[].class);
Assert.assertEquals("fourfivesix", translated[1],
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToStringArray()
{
String object1 = "onetwothree";
String object2 = "fourfivesix";
String object3 = "seveneightnine";
Object objectToTranslate = new String[]{object1, object2, object3};
public void testConvertToGeneralizedTime() throws ParseException {
String object1 = "20061005093637.44";
DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss.S");
Date expected = df.parse("20061005093637.44");
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, String[].class);
Assert.assertEquals("fourfivesix", translated[1],
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object translated = typeConverter.convertIfNecessary(object1,
Date.class);
Assert.assertEquals(translated, expected,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToGeneralizedTime() throws ParseException
{
String object1 = "20061005093637.44";
DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss.S");
Date expected = df.parse("20061005093637.44");
public void testConvertToGeneralizedTimeArray() throws ParseException {
String object1 = "20071105093655.44";
String object2 = "20061005093637.44";
Object objectToTranslate = new String[] { object1, object2 };
try
{
Object translated = typeConverter.convertIfNecessary(object1,
Date.class);
Assert.assertEquals(translated, expected,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss.S");
Date expected = df.parse("20061005093637.44");
public void testConvertToGeneralizedTimeArray() throws ParseException
{
String object1 = "20071105093655.44";
String object2 = "20061005093637.44";
Object objectToTranslate = new String[]{object1, object2};
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Date[].class);
Assert.assertEquals(translated[1], expected,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation");
}
}
DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss.S");
Date expected = df.parse("20061005093637.44");
public void testConvertToLdapName() {
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
try {
Object translated = typeConverter.convertIfNecessary(object1,
LdapName.class);
Assert.assertEquals(translated, new LdapName(object1),
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
} catch (InvalidNameException e) {
Assert.fail("Problem with test: Ldap name can't be parsed.", e);
}
}
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Date[].class);
Assert.assertEquals(translated[1], expected,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation");
}
}
public void testConvertToLdapNameArray() {
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
String object2 = "uid=fred, ou = people, dc = myretsu,dc=com";
Object objectToTranslate = new String[] { object1, object2 };
public void testConvertToLdapName()
{
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
try
{
Object translated = typeConverter.convertIfNecessary(object1,
LdapName.class);
Assert.assertEquals(translated, new LdapName(object1),
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
catch (InvalidNameException e)
{
Assert.fail("Problem with test: Ldap name can't be parsed.", e);
}
}
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, LdapName[].class);
Assert.assertEquals(new LdapName(object2), translated[1],
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
} catch (InvalidNameException e) {
Assert.fail("Problem with test: Ldap name can't be parsed.", e);
}
}
public void testConvertToLdapNameArray()
{
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
String object2 = "uid=fred, ou = people, dc = myretsu,dc=com";
Object objectToTranslate = new String[]{object1, object2};
public void testConvertToDistinguishedName() {
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
try {
Object translated = typeConverter.convertIfNecessary(object1,
DistinguishedName.class);
Assert.assertEquals(new DistinguishedName(object1), translated,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, LdapName[].class);
Assert.assertEquals(new LdapName(object2), translated[1],
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
catch (InvalidNameException e)
{
Assert.fail("Problem with test: Ldap name can't be parsed.", e);
}
}
public void testConvertToDistinguishedNameArray() {
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
String object2 = "uid=fred, ou = people, dc = myretsu,dc=com";
Object objectToTranslate = new String[] { object1, object2 };
public void testConvertToDistinguishedName()
{
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
try
{
Object translated = typeConverter.convertIfNecessary(object1,
DistinguishedName.class);
Assert.assertEquals(new DistinguishedName(object1), translated,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, DistinguishedName[].class);
Assert.assertEquals(new DistinguishedName(object2), translated[1],
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToDistinguishedNameArray()
{
String object1 = "uid=amAdmin, ou = people, dc = myretsu,dc=com";
String object2 = "uid=fred, ou = people, dc = myretsu,dc=com";
Object objectToTranslate = new String[]{object1, object2};
public void testConvertToLong() {
String object1 = "9887342";
try {
Object translated = typeConverter.convertIfNecessary(object1,
Long.class);
Assert.assertEquals(9887342L, translated,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, DistinguishedName[].class);
Assert.assertEquals(new DistinguishedName(object2), translated[1],
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToLongArray() {
String object1 = "878787";
String object2 = "23948787";
Object objectToTranslate = new String[] { object1, object2 };
public void testConvertToLong()
{
String object1 = "9887342";
try
{
Object translated = typeConverter.convertIfNecessary(object1,
Long.class);
Assert.assertEquals(9887342L, translated,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Long[].class);
Assert.assertEquals(23948787L, translated[1],
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToLongArray()
{
String object1 = "878787";
String object2 = "23948787";
Object objectToTranslate = new String[]{object1, object2};
public void testConvertToInteger() {
String object1 = "9887342";
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Long[].class);
Assert.assertEquals(23948787L, translated[1],
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object translated = typeConverter.convertIfNecessary(object1,
Integer.class);
Assert.assertEquals(9887342, translated,
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToInteger()
{
String object1 = "9887342";
public void testConvertToIntegerArray() {
String object1 = "878787";
String object2 = "23948787";
Object objectToTranslate = new String[] { object1, object2 };
try
{
Object translated = typeConverter.convertIfNecessary(object1,
Integer.class);
Assert.assertEquals(9887342, translated,
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
try {
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Integer[].class);
Assert.assertEquals(23948787, translated[1],
"Unexpected translated value");
} catch (TypeMismatchException e) {
Assert.fail("Unexpected exception during translation", e);
}
}
public void testConvertToIntegerArray()
{
String object1 = "878787";
String object2 = "23948787";
Object objectToTranslate = new String[]{object1, object2};
public void testThrowsTypeMismatchExceptionWhenTypeTranslationFails() {
String object1 = "asdlkjkalkjl";
try
{
Object[] translated = (Object[]) typeConverter.convertIfNecessary(
objectToTranslate, Integer[].class);
Assert.assertEquals(23948787, translated[1],
"Unexpected translated value");
}
catch (TypeMismatchException e)
{
Assert.fail("Unexpected exception during translation", e);
}
}
Object[] translated;
try {
translated = (Object[]) typeConverter.convertIfNecessary(object1,
LdapName.class);
Assert.fail("Should've thrown exception");
} catch (TypeMismatchException e) {
// Pass
}
}
public void testThrowsTypeMismatchExceptionWhenTypeTranslationFails()
{
String object1 = "asdlkjkalkjl";
Object[] translated;
try
{
translated = (Object[]) typeConverter.convertIfNecessary(object1,
LdapName.class);
Assert.fail("Should've thrown exception");
}
catch (TypeMismatchException e)
{
// Pass
}
}
}