diff --git a/CHANGELOG.md b/CHANGELOG.md index bcb41da..47a777a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,10 @@ This project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] +### Changed +- Builders field set method of Optional take argument of actual type rather than Optional of type +- Builders construct object with Optional.empty() if no value set for field + ## [1.7.3] - 2019-00-19 ### Changed - Upgraded framework-api to version 4.1.0 diff --git a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactory.java b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactory.java index 3d2eecd..b9b6555 100644 --- a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactory.java +++ b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactory.java @@ -1,7 +1,6 @@ package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; import static java.util.stream.Collectors.toList; -import static javax.lang.model.element.Modifier.PRIVATE; import uk.gov.justice.generation.pojo.dom.Definition; import uk.gov.justice.generation.pojo.generators.ClassNameFactory; @@ -10,29 +9,29 @@ import java.util.List; import com.squareup.javapoet.FieldSpec; -import com.squareup.javapoet.TypeName; /** * Factory for creating the fields in the Builder class */ public class BuilderFieldFactory { + private final FieldSpecFactory fieldSpecFactory; + + public BuilderFieldFactory(final FieldSpecFactory fieldSpecFactory) { + this.fieldSpecFactory = fieldSpecFactory; + } + /** - * * @param fieldDefinitions The list of {@link Definition}s from which to create fields * @param classNameFactory The factory for creating the class name - * * @return A list of {@link FieldSpec}s of the fields of the Builder */ - public List createFields( - final List fieldDefinitions, - final ClassNameFactory classNameFactory, - final PluginContext pluginContext) { + public List createFields(final List fieldDefinitions, + final ClassNameFactory classNameFactory, + final PluginContext pluginContext) { + return fieldDefinitions.stream() - .map(fieldDefinition -> { - final TypeName typeName = classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext); - return FieldSpec.builder(typeName, fieldDefinition.getFieldName(), PRIVATE).build(); - }) + .map(fieldDefinition -> fieldSpecFactory.createFieldSpecFor(fieldDefinition, classNameFactory, pluginContext)) .collect(toList()); } } diff --git a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGenerator.java b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGenerator.java index 60b43bd..a6f1613 100644 --- a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGenerator.java +++ b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGenerator.java @@ -153,6 +153,6 @@ private MethodSpec buildMethod(final ClassName pojoClassName, final List createTheWithMethods( final List fieldDefinitions, final ClassNameFactory classNameFactory, @@ -60,15 +70,16 @@ public List createTheWithMethodsWithAdditionalProperties( public MethodSpec createTheBuildMethod( final List fieldDefinitions, - final ClassName pojoClassName) { + final ClassName pojoClassName, + final PluginContext pluginContext) { - final String params = fieldDefinitions.stream() - .map(Definition::getFieldName) + final String constructorArguments = fieldDefinitions.stream() + .map(definition -> createConstructorArgumentFor(definition, pluginContext)) .collect(joining(", ")); return MethodSpec.methodBuilder("build") .addModifiers(PUBLIC) - .addStatement("return new $L(" + params + ")", pojoClassName) + .addStatement("return new $L(" + constructorArguments + ")", pojoClassName) .returns(pojoClassName) .build(); } @@ -90,6 +101,16 @@ public MethodSpec createTheBuildMethodWithAdditionalProperties( .build(); } + private String createConstructorArgumentFor(final Definition definition, final PluginContext pluginContext) { + final TypeName typeName = classNameFactory.createTypeNameFrom(definition, pluginContext); + + if (optionalTypeNameUtil.isOptionalType(typeName)) { + return "Optional.ofNullable(" + definition.getFieldName() + ")"; + } + + return definition.getFieldName(); + } + private String createStatementFormatWith(final String params) { if (params.isEmpty()) { return "return new $L($N)"; @@ -98,14 +119,13 @@ private String createStatementFormatWith(final String params) { return "return new $L(" + params + ", $N)"; } - private MethodSpec generateWithMethod( - final Definition fieldDefinition, - final ClassName builderClassName, - final ClassNameFactory classNameFactory, - final PluginContext pluginContext) { + private MethodSpec generateWithMethod(final Definition fieldDefinition, + final ClassName builderClassName, + final ClassNameFactory classNameFactory, + final PluginContext pluginContext) { final String fieldName = fieldDefinition.getFieldName(); - final TypeName typeName = classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext); + final TypeName typeName = getParameterTypeName(fieldDefinition, classNameFactory, pluginContext); return methodBuilder("with" + capitalize(fieldName)) .addModifiers(PUBLIC) @@ -118,6 +138,19 @@ private MethodSpec generateWithMethod( .build(); } + private TypeName getParameterTypeName(final Definition fieldDefinition, + final ClassNameFactory classNameFactory, + final PluginContext pluginContext) { + + final TypeName typeName = classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext); + + if (optionalTypeNameUtil.isOptionalType(typeName)) { + return optionalTypeNameUtil.getOptionalTypeFrom((ParameterizedTypeName) typeName); + } + + return typeName; + } + private MethodSpec generateWithMethodForAdditionalProperties(final ClassName builderClassName) { return methodBuilder("withAdditionalProperty") diff --git a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactory.java b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactory.java new file mode 100644 index 0000000..bd9e3de --- /dev/null +++ b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactory.java @@ -0,0 +1,38 @@ +package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; + +import static javax.lang.model.element.Modifier.PRIVATE; + +import uk.gov.justice.generation.pojo.dom.Definition; +import uk.gov.justice.generation.pojo.generators.ClassNameFactory; +import uk.gov.justice.generation.pojo.plugin.PluginContext; + +import com.squareup.javapoet.FieldSpec; +import com.squareup.javapoet.ParameterizedTypeName; +import com.squareup.javapoet.TypeName; + +public class FieldSpecFactory { + + private final OptionalTypeNameUtil optionalTypeNameUtil; + + public FieldSpecFactory(final OptionalTypeNameUtil optionalTypeNameUtil) { + this.optionalTypeNameUtil = optionalTypeNameUtil; + } + + public FieldSpec createFieldSpecFor(final Definition fieldDefinition, + final ClassNameFactory classNameFactory, + final PluginContext pluginContext) { + + final TypeName typeName = classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext); + + if (optionalTypeNameUtil.isOptionalType(typeName)) { + final TypeName parameterizedType = optionalTypeNameUtil.getOptionalTypeFrom((ParameterizedTypeName) typeName); + return FieldSpec + .builder(parameterizedType, fieldDefinition.getFieldName(), PRIVATE) + .build(); + } + + return FieldSpec + .builder(typeName, fieldDefinition.getFieldName(), PRIVATE) + .build(); + } +} diff --git a/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtil.java b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtil.java new file mode 100644 index 0000000..7406d20 --- /dev/null +++ b/pojo-generation-core/src/main/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtil.java @@ -0,0 +1,19 @@ +package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; + +import java.util.Objects; +import java.util.Optional; + +import com.squareup.javapoet.ParameterizedTypeName; +import com.squareup.javapoet.TypeName; + +public class OptionalTypeNameUtil { + + public TypeName getOptionalTypeFrom(final ParameterizedTypeName typeName) { + return typeName.typeArguments.get(0); + } + + public boolean isOptionalType(final TypeName typeName) { + return typeName instanceof ParameterizedTypeName + && Objects.equals(((ParameterizedTypeName) typeName).rawType.simpleName(), Optional.class.getSimpleName()); + } +} diff --git a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactoryTest.java b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactoryTest.java index ab91a5e..ba7afce 100644 --- a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactoryTest.java +++ b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderFieldFactoryTest.java @@ -1,9 +1,6 @@ package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; -import static com.squareup.javapoet.TypeName.get; import static java.util.Arrays.asList; -import static javax.lang.model.element.Modifier.PRIVATE; -import static org.hamcrest.CoreMatchers.hasItem; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.mock; @@ -15,15 +12,21 @@ import java.util.List; +import javax.lang.model.element.Modifier; + import com.squareup.javapoet.FieldSpec; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; @RunWith(MockitoJUnitRunner.class) public class BuilderFieldFactoryTest { + @Mock + private FieldSpecFactory fieldSpecFactory; + @InjectMocks private BuilderFieldFactory builderFieldFactory; @@ -32,32 +35,29 @@ public void shouldGenerateThePrivateFieldsForOurBuilder() throws Exception { final Definition fieldDefinition_1 = mock(Definition.class); final Definition fieldDefinition_2 = mock(Definition.class); - final List fieldDefinitions = asList(fieldDefinition_1, fieldDefinition_2); + final Definition fieldDefinition_3 = mock(Definition.class); + final List fieldDefinitions = asList(fieldDefinition_1, fieldDefinition_2, fieldDefinition_3); final ClassNameFactory classNameFactory = mock(ClassNameFactory.class); final PluginContext pluginContext = mock(PluginContext.class); - when(fieldDefinition_1.getFieldName()).thenReturn("fieldDefinition_1"); - when(fieldDefinition_2.getFieldName()).thenReturn("fieldDefinition_2"); + final FieldSpec fieldSpec_1 = FieldSpec.builder(String.class, "field_1", Modifier.PUBLIC).build(); + final FieldSpec fieldSpec_2 = FieldSpec.builder(String.class, "field_2", Modifier.PUBLIC).build(); + final FieldSpec fieldSpec_3 = FieldSpec.builder(String.class, "field_3", Modifier.PUBLIC).build(); - when(classNameFactory.createTypeNameFrom(fieldDefinition_1, pluginContext)).thenReturn(get(String.class)); - when(classNameFactory.createTypeNameFrom(fieldDefinition_2, pluginContext)).thenReturn(get(Integer.class)); + when(fieldSpecFactory.createFieldSpecFor(fieldDefinition_1, classNameFactory, pluginContext)).thenReturn(fieldSpec_1); + when(fieldSpecFactory.createFieldSpecFor(fieldDefinition_2, classNameFactory, pluginContext)).thenReturn(fieldSpec_2); + when(fieldSpecFactory.createFieldSpecFor(fieldDefinition_3, classNameFactory, pluginContext)).thenReturn(fieldSpec_3); final List fields = builderFieldFactory.createFields( fieldDefinitions, classNameFactory, pluginContext); - assertThat(fields.size(), is(2)); - - assertThat(fields.get(0).name, is("fieldDefinition_1")); - assertThat(fields.get(0).modifiers.size(), is(1)); - assertThat(fields.get(0).modifiers, hasItem(PRIVATE)); - assertThat(fields.get(0).type.toString(), is("java.lang.String")); + assertThat(fields.size(), is(3)); - assertThat(fields.get(1).name, is("fieldDefinition_2")); - assertThat(fields.get(1).modifiers.size(), is(1)); - assertThat(fields.get(1).modifiers, hasItem(PRIVATE)); - assertThat(fields.get(1).type.toString(), is("java.lang.Integer")); + assertThat(fields.get(0), is(fieldSpec_1)); + assertThat(fields.get(1), is(fieldSpec_2)); + assertThat(fields.get(2), is(fieldSpec_3)); } } diff --git a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGeneratorTest.java b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGeneratorTest.java index 3febe5d..45c06ee 100644 --- a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGeneratorTest.java +++ b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderGeneratorTest.java @@ -86,7 +86,7 @@ public void shouldGenerateABuilderWithTheCorrectFieldsBuildMethodAndWithMethods( when(additionalPropertiesDeterminer.shouldAddAdditionalProperties(classDefinition, pluginContext)).thenReturn(false); - when(builderMethodFactory.createTheBuildMethod(fieldDefinitions, pojoClassName)).thenReturn(buildMethod); + when(builderMethodFactory.createTheBuildMethod(fieldDefinitions, pojoClassName, pluginContext)).thenReturn(buildMethod); final TypeSpec builder = builderGenerator.generate(); diff --git a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderMethodFactoryTest.java b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderMethodFactoryTest.java index a690a83..dfe45c6 100644 --- a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderMethodFactoryTest.java +++ b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/BuilderMethodFactoryTest.java @@ -3,6 +3,7 @@ import static com.squareup.javapoet.ClassName.get; import static java.util.Arrays.asList; import static java.util.Collections.emptyList; +import static java.util.Collections.singletonList; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.startsWith; import static org.junit.Assert.assertThat; @@ -14,23 +15,33 @@ import uk.gov.justice.generation.pojo.plugin.PluginContext; import java.util.List; +import java.util.Optional; import com.squareup.javapoet.ClassName; import com.squareup.javapoet.MethodSpec; +import com.squareup.javapoet.ParameterizedTypeName; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; @RunWith(MockitoJUnitRunner.class) public class BuilderMethodFactoryTest { + @Mock + private ClassNameFactory classNameFactory; + + @Mock + private OptionalTypeNameUtil optionalTypeNameUtil; + @InjectMocks private BuilderMethodFactory builderMethodFactory; @Test public void shouldCreateTheBuildMethod() throws Exception { + final PluginContext pluginContext = mock(PluginContext.class); final Definition fieldDefinition_1 = mock(Definition.class); final Definition fieldDefinition_2 = mock(Definition.class); final List fieldDefinitions = asList(fieldDefinition_1, fieldDefinition_2); @@ -40,7 +51,7 @@ public void shouldCreateTheBuildMethod() throws Exception { when(fieldDefinition_1.getFieldName()).thenReturn("fieldDefinition_1"); when(fieldDefinition_2.getFieldName()).thenReturn("fieldDefinition_2"); - final MethodSpec theBuildMethod = builderMethodFactory.createTheBuildMethod(fieldDefinitions, pojoClassName); + final MethodSpec theBuildMethod = builderMethodFactory.createTheBuildMethod(fieldDefinitions, pojoClassName, pluginContext); final String expectedBuildMethod = "public org.bloggs.fred.AlcubierreDrive build() {\n " + @@ -50,6 +61,30 @@ public void shouldCreateTheBuildMethod() throws Exception { assertThat(theBuildMethod.toString(), is(expectedBuildMethod)); } + @Test + public void shouldCreateBuildMethodWithOptional() throws Exception { + + final PluginContext pluginContext = mock(PluginContext.class); + final Definition fieldDefinition = mock(Definition.class); + final ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(get(Optional.class), get(String.class)); + + final List fieldDefinitions = singletonList(fieldDefinition); + final ClassName pojoClassName = get("org.bloggs.fred", "AlcubierreDrive"); + + when(fieldDefinition.getFieldName()).thenReturn("fieldDefinition"); + when(classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext)).thenReturn(parameterizedTypeName); + when(optionalTypeNameUtil.isOptionalType(parameterizedTypeName)).thenReturn(true); + + final MethodSpec theBuildMethod = builderMethodFactory.createTheBuildMethod(fieldDefinitions, pojoClassName, pluginContext); + + final String expectedBuildMethod = + "public org.bloggs.fred.AlcubierreDrive build() {\n " + + "return new org.bloggs.fred.AlcubierreDrive(Optional.ofNullable(fieldDefinition));\n" + + "}\n"; + + assertThat(theBuildMethod.toString(), is(expectedBuildMethod)); + } + @Test public void shouldCreateTheBuildMethodWithAdditionalProperties() throws Exception { @@ -117,23 +152,66 @@ public void shouldCreateTheWithMethods() throws Exception { } @Test - public void shouldCreateTheWithMethodsWithAdditionalProperties() throws Exception { + public void shouldCreateMethodOptionalField() throws Exception { final ClassNameFactory classNameFactory = mock(ClassNameFactory.class); + final PluginContext pluginContext = mock(PluginContext.class); - final Definition fieldDefinition_1 = mock(Definition.class); - final Definition fieldDefinition_2 = mock(Definition.class); - final List fieldDefinitions = asList(fieldDefinition_1, fieldDefinition_2); + final Definition fieldDefinition = mock(Definition.class); + final ClassName className_1 = get(String.class); + final ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(get(Optional.class), get(String.class)); + + final List fieldDefinitions = singletonList(fieldDefinition); + final ClassName builderClassName = get("org.bloggs.fred", "AlcubierreDrive").nestedClass("Builder"); + + when(fieldDefinition.getFieldName()).thenReturn("fieldDefinition"); + when(classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext)).thenReturn(parameterizedTypeName); + + when(optionalTypeNameUtil.isOptionalType(className_1)).thenReturn(false); + when(optionalTypeNameUtil.isOptionalType(parameterizedTypeName)).thenReturn(true); + when(optionalTypeNameUtil.getOptionalTypeFrom(parameterizedTypeName)).thenReturn(get(String.class)); + + final List withMethods = builderMethodFactory.createTheWithMethods( + fieldDefinitions, + classNameFactory, + builderClassName, + pluginContext); + + assertThat(withMethods.size(), is(1)); + + final String expectedWithMethod = + "public org.bloggs.fred.AlcubierreDrive.Builder withFieldDefinition(" + + "final java.lang.String fieldDefinition) {\n " + + "this.fieldDefinition = fieldDefinition;\n " + + "return this;\n" + + "}\n"; + + assertThat(withMethods.get(0).toString(), is(expectedWithMethod)); + } + + @Test + public void shouldCreateMethodsWithAdditionalProperties() throws Exception { + + final ClassNameFactory classNameFactory = mock(ClassNameFactory.class); final PluginContext pluginContext = mock(PluginContext.class); + final Definition fieldDefinition_1 = mock(Definition.class); + final Definition fieldDefinition_2 = mock(Definition.class); + final ClassName className_1 = get(String.class); + final ClassName className_2 = get(Integer.class); + + final List fieldDefinitions = asList(fieldDefinition_1, fieldDefinition_2); final ClassName builderClassName = get("org.bloggs.fred", "AlcubierreDrive").nestedClass("Builder"); when(fieldDefinition_1.getFieldName()).thenReturn("fieldDefinition_1"); when(fieldDefinition_2.getFieldName()).thenReturn("fieldDefinition_2"); - when(classNameFactory.createTypeNameFrom(fieldDefinition_1, pluginContext)).thenReturn(get(String.class)); - when(classNameFactory.createTypeNameFrom(fieldDefinition_2, pluginContext)).thenReturn(get(Integer.class)); + when(classNameFactory.createTypeNameFrom(fieldDefinition_1, pluginContext)).thenReturn(className_1); + when(classNameFactory.createTypeNameFrom(fieldDefinition_2, pluginContext)).thenReturn(className_2); + + when(optionalTypeNameUtil.isOptionalType(className_1)).thenReturn(false); + when(optionalTypeNameUtil.isOptionalType(className_2)).thenReturn(false); final List withMethods = builderMethodFactory.createTheWithMethodsWithAdditionalProperties( fieldDefinitions, diff --git a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactoryTest.java b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactoryTest.java new file mode 100644 index 0000000..682039b --- /dev/null +++ b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/FieldSpecFactoryTest.java @@ -0,0 +1,76 @@ +package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; + +import static com.squareup.javapoet.TypeName.get; +import static javax.lang.model.element.Modifier.PRIVATE; +import static org.hamcrest.CoreMatchers.hasItem; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import uk.gov.justice.generation.pojo.dom.Definition; +import uk.gov.justice.generation.pojo.generators.ClassNameFactory; +import uk.gov.justice.generation.pojo.plugin.PluginContext; + +import java.util.Optional; + +import com.squareup.javapoet.ClassName; +import com.squareup.javapoet.FieldSpec; +import com.squareup.javapoet.ParameterizedTypeName; +import com.squareup.javapoet.TypeName; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class FieldSpecFactoryTest { + + @Mock + private OptionalTypeNameUtil optionalTypeNameUtil; + + @InjectMocks + private FieldSpecFactory fieldSpecFactory; + + @Test + public void shouldReturnFieldSpecForNonParameterizedType() { + + final Definition fieldDefinition = mock(Definition.class); + final ClassNameFactory classNameFactory = mock(ClassNameFactory.class); + final PluginContext pluginContext = mock(PluginContext.class); + final TypeName typeName = get(String.class); + + when(classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext)).thenReturn(typeName); + when(optionalTypeNameUtil.isOptionalType(typeName)).thenReturn(false); + when(fieldDefinition.getFieldName()).thenReturn("fieldDefinition"); + + final FieldSpec resultFieldSpec = fieldSpecFactory.createFieldSpecFor(fieldDefinition, classNameFactory, pluginContext); + + assertThat(resultFieldSpec.name, is("fieldDefinition")); + assertThat(resultFieldSpec.modifiers.size(), is(1)); + assertThat(resultFieldSpec.modifiers, hasItem(PRIVATE)); + assertThat(resultFieldSpec.type.toString(), is("java.lang.String")); + } + + @Test + public void shouldReturnFieldSpecOfParameterForOptionalParameterizedType() { + + final Definition fieldDefinition = mock(Definition.class); + final ClassNameFactory classNameFactory = mock(ClassNameFactory.class); + final PluginContext pluginContext = mock(PluginContext.class); + final ParameterizedTypeName optionalWithStringTypeName = ParameterizedTypeName.get(ClassName.get(Optional.class), ClassName.get(String.class)); + + when(classNameFactory.createTypeNameFrom(fieldDefinition, pluginContext)).thenReturn(optionalWithStringTypeName); + when(optionalTypeNameUtil.isOptionalType(optionalWithStringTypeName)).thenReturn(true); + when(optionalTypeNameUtil.getOptionalTypeFrom(optionalWithStringTypeName)).thenReturn(ClassName.get(String.class)); + when(fieldDefinition.getFieldName()).thenReturn("fieldDefinition"); + + final FieldSpec resultFieldSpec = fieldSpecFactory.createFieldSpecFor(fieldDefinition, classNameFactory, pluginContext); + + assertThat(resultFieldSpec.name, is("fieldDefinition")); + assertThat(resultFieldSpec.modifiers.size(), is(1)); + assertThat(resultFieldSpec.modifiers, hasItem(PRIVATE)); + assertThat(resultFieldSpec.type.toString(), is("java.lang.String")); + } +} \ No newline at end of file diff --git a/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtilTest.java b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtilTest.java new file mode 100644 index 0000000..e19231e --- /dev/null +++ b/pojo-generation-core/src/test/java/uk/gov/justice/generation/pojo/plugin/classmodifying/builder/OptionalTypeNameUtilTest.java @@ -0,0 +1,63 @@ +package uk.gov.justice.generation.pojo.plugin.classmodifying.builder; + +import static com.squareup.javapoet.TypeName.get; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import java.util.List; +import java.util.Optional; + +import com.squareup.javapoet.ClassName; +import com.squareup.javapoet.ParameterizedTypeName; +import com.squareup.javapoet.TypeName; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class OptionalTypeNameUtilTest { + + @InjectMocks + private OptionalTypeNameUtil optionalTypeNameUtil; + + @Test + public void shouldReturnTrueForOptionalParameterizedType() { + + final ParameterizedTypeName optionalWithStringTypeName = ParameterizedTypeName.get(ClassName.get(Optional.class), ClassName.get(String.class)); + + final boolean result = optionalTypeNameUtil.isOptionalType(optionalWithStringTypeName); + + assertThat(result, is(true)); + } + + @Test + public void shouldReturnFalseForNonParameterizedType() { + + final TypeName typeName = get(String.class); + + final boolean result = optionalTypeNameUtil.isOptionalType(typeName); + + assertThat(result, is(false)); + } + + @Test + public void shouldReturnFalseForNonOptionalParameterizedType() { + + final ParameterizedTypeName optionalWithStringTypeName = ParameterizedTypeName.get(ClassName.get(List.class), ClassName.get(String.class)); + + final boolean result = optionalTypeNameUtil.isOptionalType(optionalWithStringTypeName); + + assertThat(result, is(false)); + } + + @Test + public void shouldReturnParameterTypeOfOptionalType() { + + final ParameterizedTypeName optionalWithStringTypeName = ParameterizedTypeName.get(ClassName.get(Optional.class), ClassName.get(String.class)); + + final TypeName typeName = optionalTypeNameUtil.getOptionalTypeFrom(optionalWithStringTypeName); + + assertThat(typeName, is(ClassName.get(String.class))); + } +} \ No newline at end of file