Add tests for schema pojo generator providers

CJSCommonPlatform · Sep 26, 2017 · 8f5d81b · 8f5d81b
1 parent 028a547
commit 8f5d81b
Show file tree

Hide file tree

Showing 16 changed files with 377 additions and 61 deletions.
diff --git a/pojo-generator-core/src/main/java/uk/gov/justice/generation/DefinitionProvider.java b/pojo-generator-core/src/main/java/uk/gov/justice/generation/DefinitionProvider.java
@@ -5,30 +5,41 @@
 import uk.gov.justice.generation.pojo.plugin.PluginProvider;
 import uk.gov.justice.generation.pojo.plugin.classmodifying.PluginContext;
 import uk.gov.justice.generation.pojo.visitable.VisitableFactory;
-import uk.gov.justice.generation.pojo.visitable.acceptor.DefaultAcceptorService;
-import uk.gov.justice.generation.pojo.visitor.DefaultDefinitionFactory;
+import uk.gov.justice.generation.pojo.visitable.acceptor.AcceptorService;
 import uk.gov.justice.generation.pojo.visitor.DefinitionBuilderVisitor;
-import uk.gov.justice.generation.pojo.visitor.ReferenceValueParser;
 
 import java.io.File;
 import java.util.List;
 
+import org.everit.json.schema.Schema;
+
 public class DefinitionProvider {
 
-    private final SchemaLoader schemaLoader = new SchemaLoader();
-    private final VisitableFactory visitableFactory = new VisitableFactory();
-    private DefinitionBuilderVisitor definitionBuilderVisitor = new DefinitionBuilderVisitor(new DefaultDefinitionFactory(new ReferenceValueParser()));
+    private final SchemaLoader schemaLoader;
+    private final VisitableFactory visitableFactory;
+    private final DefinitionBuilderVisitor definitionBuilderVisitor;
+    private final AcceptorService acceptorService;
+
+    public DefinitionProvider(final SchemaLoader schemaLoader,
+                              final VisitableFactory visitableFactory,
+                              final DefinitionBuilderVisitor definitionBuilderVisitor,
+                              final AcceptorService acceptorService) {
+        this.schemaLoader = schemaLoader;
+        this.visitableFactory = visitableFactory;
+        this.definitionBuilderVisitor = definitionBuilderVisitor;
+        this.acceptorService = acceptorService;
+    }
 
     public List<Definition> createDefinitions(final File source, final PluginProvider pluginProvider, final PluginContext pluginContext) {
 
+        final Schema schema = schemaLoader.loadFrom(source);
+
         final String fieldName = pluginProvider
                 .nameGeneratablePlugin()
-                .rootFieldNameFrom(schemaLoader.loadFrom(source), source.getName(), pluginContext);
+                .rootFieldNameFrom(schema, source.getName(), pluginContext);
 
-        visitableFactory.createWith(
-                fieldName,
-                schemaLoader.loadFrom(source),
-                new DefaultAcceptorService(visitableFactory))
+        visitableFactory
+                .createWith(fieldName, schema, acceptorService)
                 .accept(definitionBuilderVisitor);
 
         return definitionBuilderVisitor.getDefinitions();

diff --git a/pojo-generator-core/src/main/java/uk/gov/justice/generation/GeneratorContextProvider.java b/pojo-generator-core/src/main/java/uk/gov/justice/generation/GeneratorContextProvider.java
@@ -5,21 +5,30 @@
 import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorConfig;
 
 import java.io.File;
+import java.nio.file.Path;
 import java.util.List;
 
 public class GeneratorContextProvider {
 
-    private final JavaFileSimpleNameLister javaFileSimpleNameLister = new JavaFileSimpleNameLister();
+    private final JavaFileSimpleNameLister javaFileSimpleNameLister;
+
+    public GeneratorContextProvider(final JavaFileSimpleNameLister javaFileSimpleNameLister) {
+        this.javaFileSimpleNameLister = javaFileSimpleNameLister;
+    }
 
     public GenerationContext getGenerationContext(final File jsonSchemaFile, final GeneratorConfig generatorConfig) {
+        final List<Path> sourcePaths = generatorConfig.getSourcePaths();
+        final Path outputDirectory = generatorConfig.getOutputDirectory();
+        final String basePackageName = generatorConfig.getBasePackageName();
+
         final List<String> hardCodedClassNames = javaFileSimpleNameLister.findSimpleNames(
-                generatorConfig.getSourcePaths(),
-                generatorConfig.getOutputDirectory(),
-                generatorConfig.getBasePackageName());
+                sourcePaths,
+                outputDirectory,
+                basePackageName);
 
         return new GenerationContext(
-                generatorConfig.getOutputDirectory(),
-                generatorConfig.getBasePackageName(),
+                outputDirectory,
+                basePackageName,
                 jsonSchemaFile.getName(),
                 hardCodedClassNames);
     }

diff --git a/pojo-generator-core/src/main/java/uk/gov/justice/generation/JavaClassFileWriter.java b/pojo-generator-core/src/main/java/uk/gov/justice/generation/JavaClassFileWriter.java
@@ -2,18 +2,19 @@
 
 import uk.gov.justice.generation.pojo.core.GenerationContext;
 import uk.gov.justice.generation.pojo.generators.ClassGeneratable;
-import uk.gov.justice.generation.pojo.write.JavaSourceFileProvider;
 import uk.gov.justice.generation.pojo.write.NonDuplicatingSourceWriter;
-import uk.gov.justice.generation.pojo.write.SourceWriter;
 
 import java.util.List;
 
 public class JavaClassFileWriter {
 
-    private final SourceWriter sourceWriter = new SourceWriter();
+    private final NonDuplicatingSourceWriter writer;
+
+    public JavaClassFileWriter(final NonDuplicatingSourceWriter writer) {
+        this.writer = writer;
+    }
 
     public void writeJavaClassesToFile(final GenerationContext generationContext, final List<ClassGeneratable> classGenerators) {
-        final NonDuplicatingSourceWriter writer = new NonDuplicatingSourceWriter(new JavaSourceFileProvider(), sourceWriter);
         classGenerators.forEach(classGeneratable -> writer.write(classGeneratable, generationContext));
     }
 }
diff --git a/pojo-generator-core/src/main/java/uk/gov/justice/generation/SchemaPojoGeneratorFactory.java b/pojo-generator-core/src/main/java/uk/gov/justice/generation/SchemaPojoGeneratorFactory.java
@@ -1,21 +1,42 @@
 package uk.gov.justice.generation;
 
+import uk.gov.justice.generation.io.files.JavaFileSimpleNameLister;
+import uk.gov.justice.generation.io.files.loader.SchemaLoader;
 import uk.gov.justice.generation.pojo.plugin.PluginProviderFactoryFactory;
+import uk.gov.justice.generation.pojo.visitable.VisitableFactory;
+import uk.gov.justice.generation.pojo.visitable.acceptor.AcceptorService;
+import uk.gov.justice.generation.pojo.visitable.acceptor.DefaultAcceptorService;
+import uk.gov.justice.generation.pojo.visitor.DefaultDefinitionFactory;
+import uk.gov.justice.generation.pojo.visitor.DefinitionBuilderVisitor;
+import uk.gov.justice.generation.pojo.visitor.ReferenceValueParser;
+import uk.gov.justice.generation.pojo.write.JavaSourceFileProvider;
+import uk.gov.justice.generation.pojo.write.NonDuplicatingSourceWriter;
+import uk.gov.justice.generation.pojo.write.SourceWriter;
 import uk.gov.justice.maven.generator.io.files.parser.core.Generator;
 import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorFactory;
 
 import java.io.File;
 
 public class SchemaPojoGeneratorFactory implements GeneratorFactory<File> {
 
+    private final SchemaLoader schemaLoader = new SchemaLoader();
+    private final VisitableFactory visitableFactory = new VisitableFactory();
+    private final DefinitionBuilderVisitor definitionBuilderVisitor = new DefinitionBuilderVisitor(new DefaultDefinitionFactory(new ReferenceValueParser()));
+    private final AcceptorService acceptorService = new DefaultAcceptorService(visitableFactory);
+
+    private final JavaFileSimpleNameLister javaFileSimpleNameLister = new JavaFileSimpleNameLister();
+
+    private final SourceWriter sourceWriter = new SourceWriter();
+    private NonDuplicatingSourceWriter writer = new NonDuplicatingSourceWriter(new JavaSourceFileProvider(), sourceWriter);
+
     @Override
     public Generator<File> create() {
         return new SchemaPojoGenerator(
                 new PluginProviderFactoryFactory().create(),
-                new DefinitionProvider(),
-                new GeneratorContextProvider(),
+                new DefinitionProvider(schemaLoader, visitableFactory, definitionBuilderVisitor, acceptorService),
+                new GeneratorContextProvider(javaFileSimpleNameLister),
                 new ClassNameFactoryProvider(),
                 new JavaGeneratorFactoryProvider(),
-                new JavaClassFileWriter());
+                new JavaClassFileWriter(writer));
     }
 }
diff --git a/...-generator-core/src/test/java/uk/gov/justice/generation/ClassNameFactoryProviderTest.java b/...-generator-core/src/test/java/uk/gov/justice/generation/ClassNameFactoryProviderTest.java
@@ -0,0 +1,32 @@
+package uk.gov.justice.generation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static uk.gov.justice.generation.utils.ReflectionUtil.fieldValue;
+
+import uk.gov.justice.generation.pojo.core.GenerationContext;
+import uk.gov.justice.generation.pojo.generators.ClassNameFactory;
+import uk.gov.justice.generation.pojo.plugin.PluginProvider;
+
+import org.junit.Test;
+
+public class ClassNameFactoryProviderTest {
+
+    @Test
+    public void shouldProvideClassNameFactory() throws Exception {
+        final GenerationContext generationContext = mock(GenerationContext.class);
+        final PluginProvider pluginProvider = mock(PluginProvider.class);
+
+        final ClassNameFactory classNameFactory = new ClassNameFactoryProvider().getClassNameFactory(generationContext, pluginProvider);
+
+        assertThat(classNameFactory, notNullValue());
+
+        final Object typeNameProvider = fieldValue(classNameFactory, "typeNameProvider");
+        assertThat(fieldValue(typeNameProvider, "generationContext"), is(generationContext));
+
+        final Object typeNamePluginProcessor = fieldValue(classNameFactory, "typeNamePluginProcessor");
+        assertThat(fieldValue(typeNamePluginProcessor, "pluginProvider"), is(pluginProvider));
+    }
+}
diff --git a/pojo-generator-core/src/test/java/uk/gov/justice/generation/DefinitionProviderTest.java b/pojo-generator-core/src/test/java/uk/gov/justice/generation/DefinitionProviderTest.java
@@ -0,0 +1,73 @@
+package uk.gov.justice.generation;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import uk.gov.justice.generation.io.files.loader.SchemaLoader;
+import uk.gov.justice.generation.pojo.dom.Definition;
+import uk.gov.justice.generation.pojo.plugin.PluginProvider;
+import uk.gov.justice.generation.pojo.plugin.classmodifying.PluginContext;
+import uk.gov.justice.generation.pojo.plugin.namegeneratable.NameGeneratablePlugin;
+import uk.gov.justice.generation.pojo.visitable.Visitable;
+import uk.gov.justice.generation.pojo.visitable.VisitableFactory;
+import uk.gov.justice.generation.pojo.visitable.acceptor.AcceptorService;
+import uk.gov.justice.generation.pojo.visitor.DefinitionBuilderVisitor;
+
+import java.io.File;
+import java.util.List;
+
+import org.everit.json.schema.Schema;
+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 DefinitionProviderTest {
+
+    @Mock
+    private SchemaLoader schemaLoader;
+
+    @Mock
+    private VisitableFactory visitableFactory;
+
+    @Mock
+    private DefinitionBuilderVisitor definitionBuilderVisitor;
+
+    @Mock
+    private AcceptorService acceptorService;
+
+    @InjectMocks
+    private DefinitionProvider definitionProvider;
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldCreateDefinitions() throws Exception {
+        final String fieldName = "fieldName";
+        final String schemaFilename = "schemaFilename";
+
+        final List<Definition> definitions = mock(List.class);
+        final File schemaFile = mock(File.class);
+        final Schema schema = mock(Schema.class);
+
+        final PluginProvider pluginProvider = mock(PluginProvider.class);
+        final PluginContext pluginContext = mock(PluginContext.class);
+        final NameGeneratablePlugin nameGeneratablePlugin = mock(NameGeneratablePlugin.class);
+
+        when(schemaLoader.loadFrom(schemaFile)).thenReturn(schema);
+        when(pluginProvider.nameGeneratablePlugin()).thenReturn(nameGeneratablePlugin);
+
+        when(schemaFile.getName()).thenReturn(schemaFilename);
+        when(nameGeneratablePlugin.rootFieldNameFrom(schema, schemaFilename, pluginContext)).thenReturn(fieldName);
+
+        when(visitableFactory.createWith(fieldName, schema, acceptorService)).thenReturn(mock(Visitable.class));
+        when(definitionBuilderVisitor.getDefinitions()).thenReturn(definitions);
+
+        final List<Definition> result = definitionProvider.createDefinitions(schemaFile, pluginProvider, pluginContext);
+
+        assertThat(result, is(definitions));
+    }
+}
diff --git a/...-generator-core/src/test/java/uk/gov/justice/generation/GeneratorContextProviderTest.java b/...-generator-core/src/test/java/uk/gov/justice/generation/GeneratorContextProviderTest.java
@@ -0,0 +1,57 @@
+package uk.gov.justice.generation;
+
+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.io.files.JavaFileSimpleNameLister;
+import uk.gov.justice.generation.pojo.core.GenerationContext;
+import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorConfig;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+
+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 GeneratorContextProviderTest {
+
+    @Mock
+    private JavaFileSimpleNameLister javaFileSimpleNameLister;
+
+    @InjectMocks
+    private GeneratorContextProvider generatorContextProvider;
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldProvideGeneratorContext() throws Exception {
+        final String packageName = "package.name";
+        final String schemaFilename = "schemaFilename";
+        final Path outputDirectory = mock(Path.class);
+        final List<String> hardCodedClassNames = mock(List.class);
+
+        final List<Path> sourcePaths = mock(List.class);
+        final File schemaFile = mock(File.class);
+        final GeneratorConfig generatorConfig = mock(GeneratorConfig.class);
+
+        when(generatorConfig.getSourcePaths()).thenReturn(sourcePaths);
+        when(generatorConfig.getOutputDirectory()).thenReturn(outputDirectory);
+        when(generatorConfig.getBasePackageName()).thenReturn(packageName);
+        when(javaFileSimpleNameLister.findSimpleNames(sourcePaths, outputDirectory, packageName)).thenReturn(hardCodedClassNames);
+
+        when(schemaFile.getName()).thenReturn(schemaFilename);
+
+        final GenerationContext generationContext = generatorContextProvider.getGenerationContext(schemaFile, generatorConfig);
+
+        assertThat(generationContext.getPackageName(), is(packageName));
+        assertThat(generationContext.getOutputDirectoryPath(), is(outputDirectory));
+        assertThat(generationContext.getSourceFilename(), is(schemaFilename));
+        assertThat(generationContext.getIgnoredClassNames(), is(hardCodedClassNames));
+    }
+}
diff --git a/pojo-generator-core/src/test/java/uk/gov/justice/generation/JavaClassFileWriterTest.java b/pojo-generator-core/src/test/java/uk/gov/justice/generation/JavaClassFileWriterTest.java
@@ -0,0 +1,40 @@
+package uk.gov.justice.generation;
+
+import static java.util.Collections.singletonList;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import uk.gov.justice.generation.pojo.core.GenerationContext;
+import uk.gov.justice.generation.pojo.generators.ClassGeneratable;
+import uk.gov.justice.generation.pojo.write.NonDuplicatingSourceWriter;
+
+import java.util.List;
+
+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 JavaClassFileWriterTest {
+
+    @Mock
+    private NonDuplicatingSourceWriter nonDuplicatingSourceWriter;
+
+    @InjectMocks
+    private JavaClassFileWriter javaClassFileWriter;
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldWriteJavaClassFiles() throws Exception {
+        final GenerationContext generationContext = mock(GenerationContext.class);
+        final ClassGeneratable classGeneratable = mock(ClassGeneratable.class);
+        final List<ClassGeneratable> classGenerators = singletonList(classGeneratable);
+
+        javaClassFileWriter.writeJavaClassesToFile(generationContext, classGenerators);
+
+        verify(nonDuplicatingSourceWriter, times(1)).write(classGeneratable, generationContext);
+    }
+}
diff --git a/...erator-core/src/test/java/uk/gov/justice/generation/JavaGeneratorFactoryProviderTest.java b/...erator-core/src/test/java/uk/gov/justice/generation/JavaGeneratorFactoryProviderTest.java
@@ -0,0 +1,23 @@
+package uk.gov.justice.generation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static uk.gov.justice.generation.utils.ReflectionUtil.fieldValue;
+
+import uk.gov.justice.generation.pojo.generators.ClassNameFactory;
+import uk.gov.justice.generation.pojo.generators.JavaGeneratorFactory;
+
+import org.junit.Test;
+
+public class JavaGeneratorFactoryProviderTest {
+
+    @Test
+    public void shouldProvideJavaGeneratorFactory() throws Exception {
+        final ClassNameFactory classNameFactory = mock(ClassNameFactory.class);
+
+        final JavaGeneratorFactory javaGeneratorFactory = new JavaGeneratorFactoryProvider().getJavaGeneratorFactory(classNameFactory);
+
+        assertThat(fieldValue(javaGeneratorFactory, "classNameFactory"), is(classNameFactory));
+    }
+}