DATACMNS-266 - Use new common Maven build infrastructure.

Simplified project setup to be a single module build again. Using Spring Data Build parent POM to simplify project setup. See https://github.com/SpringSource/spring-data-build#spring-data-build-infrastructure

src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2011-2012 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.data.convert;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.TypeInformation;
+
+/**
+ * Unit tests for {@link ConfigurableTypeMapper}.
+ * 
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class ConfigurableTypeInformationMapperUnitTests<T extends PersistentProperty<T>> {
+
+	ConfigurableTypeInformationMapper mapper;
+
+	@Before
+	public void setUp() {
+		mapper = new ConfigurableTypeInformationMapper(Collections.singletonMap(String.class, "1"));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullTypeMap() {
+		new ConfigurableTypeInformationMapper(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNonBijectionalMap() {
+
+		Map<Class<?>, String> map = new HashMap<Class<?>, String>();
+		map.put(String.class, "1");
+		map.put(Object.class, "1");
+
+		new ConfigurableTypeInformationMapper(map);
+	}
+
+	@Test
+	public void writesMapKeyForType() {
+
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(String.class)), is((Object) "1"));
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Object.class)), is(nullValue()));
+	}
+
+	@Test
+	@SuppressWarnings("rawtypes")
+	public void readsTypeForMapKey() {
+
+		assertThat(mapper.resolveTypeFrom("1"), is((TypeInformation) ClassTypeInformation.from(String.class)));
+		assertThat(mapper.resolveTypeFrom("unmapped"), is(nullValue()));
+	}
+}

src/test/java/org/springframework/data/convert/EntityInstantiatorsUnitTests.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2012 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.data.convert;
+
+import static org.mockito.Mockito.*;
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mapping.PersistentEntity;
+
+/**
+ * Unit tests for {@link EntityInstantiators}.
+ * 
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EntityInstantiatorsUnitTests {
+
+	@Mock
+	PersistentEntity<?, ?> entity;
+
+	@Mock
+	EntityInstantiator customInstantiator;
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFallbackInstantiator() {
+		new EntityInstantiators((EntityInstantiator) null);
+	}
+
+	@Test
+	public void usesReflectionEntityInstantiatorAsDefaultFallback() {
+
+		EntityInstantiators instantiators = new EntityInstantiators();
+		assertThat(instantiators.getInstantiatorFor(entity), is((EntityInstantiator) ReflectionEntityInstantiator.INSTANCE));
+	}
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void returnsCustomInstantiatorForTypeIfRegistered() {
+
+		when(entity.getType()).thenReturn((Class) String.class);
+
+		Map<Class<?>, EntityInstantiator> customInstantiators = Collections.<Class<?>, EntityInstantiator> singletonMap(
+				String.class, customInstantiator);
+
+		EntityInstantiators instantiators = new EntityInstantiators(customInstantiators);
+		assertThat(instantiators.getInstantiatorFor(entity), is(customInstantiator));
+	}
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void usesCustomFallbackInstantiatorsIfConfigured() {
+
+		when(entity.getType()).thenReturn((Class) Object.class);
+
+		Map<Class<?>, EntityInstantiator> customInstantiators = Collections.<Class<?>, EntityInstantiator> singletonMap(
+				String.class, ReflectionEntityInstantiator.INSTANCE);
+
+		EntityInstantiators instantiators = new EntityInstantiators(customInstantiator, customInstantiators);
+		instantiators.getInstantiatorFor(entity);
+
+		assertThat(instantiators.getInstantiatorFor(entity), is(customInstantiator));
+
+		when(entity.getType()).thenReturn((Class) String.class);
+		assertThat(instantiators.getInstantiatorFor(entity), is((EntityInstantiator) ReflectionEntityInstantiator.INSTANCE));
+	}
+}

src/test/java/org/springframework/data/convert/MappingContextTypeInformationMapperUnitTests.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2012 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.data.convert;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.springframework.data.util.ClassTypeInformation.*;
+
+import java.util.Collections;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.data.annotation.TypeAlias;
+import org.springframework.data.mapping.MappingMetadataTests;
+import org.springframework.data.mapping.MappingMetadataTests.SampleMappingContext;
+import org.springframework.data.mapping.MappingMetadataTests.SampleProperty;
+import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.TypeInformation;
+
+/**
+ * Unit tests for {@link MappingContextTypeInformationMapper}.
+ * 
+ * @author Oliver Gierke
+ */
+public class MappingContextTypeInformationMapperUnitTests {
+
+	SampleMappingContext mappingContext;
+	TypeInformationMapper mapper;
+
+	@Before
+	public void setUp() {
+		mappingContext = new MappingMetadataTests.SampleMappingContext();
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullMappingContext() {
+		new MappingContextTypeInformationMapper(null);
+	}
+
+	@Test
+	public void extractsAliasInfoFromMappingContext() {
+
+		mappingContext.setInitialEntitySet(Collections.singleton(Entity.class));
+		mappingContext.initialize();
+
+		mapper = new MappingContextTypeInformationMapper(mappingContext);
+
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Entity.class)), is((Object) "foo"));
+	}
+
+	@Test
+	public void extractsAliasForUnknownType() {
+
+		SampleMappingContext mappingContext = new MappingMetadataTests.SampleMappingContext();
+		mappingContext.initialize();
+
+		mapper = new MappingContextTypeInformationMapper(mappingContext);
+
+		assertThat(mapper.createAliasFor(from(Entity.class)), is((Object) "foo"));
+	}
+
+	@Test
+	public void doesNotReturnTypeAliasForSimpleType() {
+
+		SampleMappingContext mappingContext = new MappingMetadataTests.SampleMappingContext();
+		mappingContext.initialize();
+
+		mapper = new MappingContextTypeInformationMapper(mappingContext);
+		assertThat(mapper.createAliasFor(from(String.class)), is(nullValue()));
+	}
+
+	@Test
+	@SuppressWarnings("rawtypes")
+	public void detectsTypeForUnknownEntity() {
+
+		SampleMappingContext mappingContext = new MappingMetadataTests.SampleMappingContext();
+		mappingContext.initialize();
+
+		mapper = new MappingContextTypeInformationMapper(mappingContext);
+		assertThat(mapper.resolveTypeFrom("foo"), is(nullValue()));
+
+		PersistentEntity<?, SampleProperty> entity = mappingContext.getPersistentEntity(Entity.class);
+
+		assertThat(entity, is(notNullValue()));
+		assertThat(mapper.resolveTypeFrom("foo"), is((TypeInformation) from(Entity.class)));
+	}
+
+	@TypeAlias("foo")
+	static class Entity {
+
+	}
+}

src/test/java/org/springframework/data/convert/ReflectionEntityInstantiatorUnitTests.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2012 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.data.convert;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+import static org.springframework.data.convert.ReflectionEntityInstantiator.*;
+
+import java.lang.reflect.Field;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.convert.ReflectionEntityInstantiatorUnitTests.Outer.Inner;
+import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.PreferredConstructor;
+import org.springframework.data.mapping.PreferredConstructor.Parameter;
+import org.springframework.data.mapping.model.BasicPersistentEntity;
+import org.springframework.data.mapping.model.ParameterValueProvider;
+import org.springframework.data.mapping.model.PreferredConstructorDiscoverer;
+import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.util.ReflectionUtils.FieldCallback;
+
+/**
+ * Unit tests for {@link ReflectionEntityInstantiator}.
+ * 
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class ReflectionEntityInstantiatorUnitTests<P extends PersistentProperty<P>> {
+
+	@Mock
+	PersistentEntity<?, P> entity;
+	@Mock
+	ParameterValueProvider<P> provider;
+	@Mock
+	PreferredConstructor<?, P> constructor;
+	@Mock
+	Parameter<?, P> parameter;
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void instantiatesSimpleObjectCorrectly() {
+
+		when(entity.getType()).thenReturn((Class) Object.class);
+		INSTANCE.createInstance(entity, provider);
+	}
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void instantiatesArrayCorrectly() {
+
+		when(entity.getType()).thenReturn((Class) String[][].class);
+		INSTANCE.createInstance(entity, provider);
+	}
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void instantiatesTypeWithPreferredConstructorUsingParameterValueProvider() {
+
+		PreferredConstructor constructor = new PreferredConstructorDiscoverer<Foo, P>(Foo.class).getConstructor();
+
+		when(entity.getType()).thenReturn((Class) Foo.class);
+		when(entity.getPersistenceConstructor()).thenReturn(constructor);
+
+		Object instance = INSTANCE.createInstance(entity, provider);
+
+		assertTrue(instance instanceof Foo);
+		verify(provider, times(1)).getParameterValue((Parameter) constructor.getParameters().iterator().next());
+	}
+
+	/**
+	 * @see DATACMNS-134
+	 */
+	@Test
+	public void createsInnerClassInstanceCorrectly() {
+
+		BasicPersistentEntity<Inner, P> entity = new BasicPersistentEntity<Inner, P>(ClassTypeInformation.from(Inner.class));
+		PreferredConstructor<Inner, P> constructor = entity.getPersistenceConstructor();
+		Parameter<Object, P> parameter = constructor.getParameters().iterator().next();
+
+		final Object outer = new Outer();
+
+		when(provider.getParameterValue(parameter)).thenReturn(outer);
+		final Inner instance = INSTANCE.createInstance(entity, provider);
+
+		assertThat(instance, is(notNullValue()));
+
+		// Hack to check syntheic field as compiles create different field names (e.g. this$0, this$1)
+		ReflectionUtils.doWithFields(Inner.class, new FieldCallback() {
+			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
+				if (field.isSynthetic() && field.getName().startsWith("this$")) {
+					ReflectionUtils.makeAccessible(field);
+					assertThat(ReflectionUtils.getField(field, instance), is(outer));
+				}
+			}
+		});
+	}
+
+	static class Foo {
+
+		Foo(String foo) {
+
+		}
+	}
+
+	static class Outer {
+
+		class Inner {
+
+		}
+	}
+}

src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012 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.data.convert;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.TypeInformation;
+
+/**
+ * 
+ * @author Oliver Gierke
+ */
+public class SimpleTypeInformationMapperUnitTests {
+
+	@Test
+	@SuppressWarnings({ "rawtypes" })
+	public void resolvesTypeByLoadingClass() {
+
+		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+		TypeInformation type = mapper.resolveTypeFrom("java.lang.String");
+
+		TypeInformation expected = ClassTypeInformation.from(String.class);
+
+		assertThat(type, is(expected));
+	}
+
+	@Test
+	public void returnsNullForNonStringKey() {
+
+		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+		assertThat(mapper.resolveTypeFrom(new Object()), is(nullValue()));
+	}
+
+	@Test
+	public void returnsNullForEmptyTypeKey() {
+
+		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+		assertThat(mapper.resolveTypeFrom(""), is(nullValue()));
+	}
+
+	@Test
+	public void returnsNullForUnloadableClass() {
+
+		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+		assertThat(mapper.resolveTypeFrom("Foo"), is(nullValue()));
+	}
+
+	@Test
+	public void usesFullyQualifiedClassNameAsTypeKey() {
+
+		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+		Object alias = mapper.createAliasFor(ClassTypeInformation.from(String.class));
+
+		assertTrue(alias instanceof String);
+		assertThat(alias, is((Object) String.class.getName()));
+	}
+}