From be21677bbd8fbe447b619be64cd68c44e7245cab Mon Sep 17 00:00:00 2001 From: amckenzie Date: Mon, 4 Dec 2017 15:11:38 +0000 Subject: [PATCH] refactor catalog mappings --- .../gov/justice/schema/catalog/Catalog.java | 37 +++ .../justice/schema/catalog/CatalogLoader.java | 40 --- .../schema/catalog/CatalogObjectFactory.java | 79 ++++++ .../schema/catalog/CatalogProducer.java | 13 + .../catalog/CatalogToSchemaResolver.java | 20 +- .../catalog/ClasspathCatalogLoader.java | 3 - .../schema/catalog/JsonSchemaFileLoader.java | 13 +- .../justice/schema/catalog/RawCatalog.java | 26 ++ .../schema/catalog/SchemaResolver.java | 3 - .../catalog/SchemaResolverAndLoader.java | 28 --- .../client/LocalFileSystemSchemaClient.java | 29 +++ .../client/SchemaClientException.java | 2 +- .../catalog/client/SchemaClientFactory.java | 12 + .../src/main/resources/META-INF/beans.xml | 2 +- .../schema/catalog/CatalogLoaderTest.java | 58 ----- .../catalog/CatalogObjectFactoryTest.java | 162 ++++++++++++ .../schema/catalog/CatalogProducerTest.java | 41 ++++ .../justice/schema/catalog/CatalogTest.java | 61 +++++ .../catalog/CatalogToSchemaResolverTest.java | 5 +- .../catalog/JsonSchemaFileLoaderTest.java | 12 +- .../schema/catalog/RawCatalogTest.java | 96 ++++++++ .../catalog/SchemaResolverAndLoaderTest.java | 78 ------ .../LocalFileSystemSchemaClientTest.java | 38 ++- .../client/SchemaClientFactoryTest.java | 17 +- catalog-generation-plugin-it/pom.xml | 1 - .../generation/GenerationObjectFactory.java | 33 +++ .../catalog/generation/ObjectFactory.java | 107 -------- .../maven/MavenCatalogGenerator.java | 10 +- .../maven/MavenCatalogGeneratorFactory.java | 4 +- .../GenerationObjectFactoryTest.java | 86 +++++++ .../catalog/generation/ObjectFactoryTest.java | 230 ------------------ .../maven/MavenCatalogGeneratorTest.java | 6 +- .../client/LocalFileSystemSchemaClient.java | 29 --- .../schema/client/SchemaClientFactory.java | 12 - .../{CatalogLoaderIT.java => CatalogIT.java} | 20 +- pom.xml | 2 +- .../catalog/ExampleCatalogLoaderIT.java | 18 +- .../schema/service/SchemaCatalogService.java | 24 +- .../service/SchemaCatalogServiceTest.java | 51 ++-- .../schema/service/SchemaServiceIT.java | 31 +-- 40 files changed, 801 insertions(+), 738 deletions(-) create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/Catalog.java delete mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogLoader.java create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogObjectFactory.java create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogProducer.java create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/RawCatalog.java delete mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoader.java create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClient.java rename {everit-schema-client/src/main/java/uk/gov/justice/schema => catalog-core/src/main/java/uk/gov/justice/schema/catalog}/client/SchemaClientException.java (76%) create mode 100644 catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientFactory.java delete mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderTest.java create mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogObjectFactoryTest.java create mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogProducerTest.java create mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogTest.java create mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/RawCatalogTest.java delete mode 100644 catalog-core/src/test/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoaderTest.java rename {everit-schema-client/src/test/java/uk/gov/justice/schema => catalog-core/src/test/java/uk/gov/justice/schema/catalog}/client/LocalFileSystemSchemaClientTest.java (51%) rename {everit-schema-client/src/test/java/uk/gov/justice/schema => catalog-core/src/test/java/uk/gov/justice/schema/catalog}/client/SchemaClientFactoryTest.java (64%) create mode 100644 catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactory.java delete mode 100644 catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/ObjectFactory.java create mode 100644 catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactoryTest.java delete mode 100644 catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/ObjectFactoryTest.java delete mode 100644 everit-schema-client/src/main/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClient.java delete mode 100644 everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientFactory.java rename integration-test/src/test/java/uk/gov/justice/schema/catalog/{CatalogLoaderIT.java => CatalogIT.java} (71%) diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/Catalog.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/Catalog.java new file mode 100644 index 0000000..20ab796 --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/Catalog.java @@ -0,0 +1,37 @@ +package uk.gov.justice.schema.catalog; + +import static java.util.Optional.empty; +import static java.util.Optional.of; + +import uk.gov.justice.schema.catalog.client.SchemaClientFactory; + +import java.util.Optional; + +import org.everit.json.schema.Schema; +import org.everit.json.schema.loader.SchemaClient; + +public class Catalog { + + private final RawCatalog rawCatalog; + private final SchemaClientFactory schemaClientFactory; + private final JsonStringToSchemaConverter jsonStringToSchemaConverter; + + public Catalog(final RawCatalog rawCatalog, final SchemaClientFactory schemaClientFactory, final JsonStringToSchemaConverter jsonStringToSchemaConverter) { + this.rawCatalog = rawCatalog; + this.schemaClientFactory = schemaClientFactory; + this.jsonStringToSchemaConverter = jsonStringToSchemaConverter; + } + + public Optional getSchema(final String schemaId) { + + final Optional rawJsonSchema = rawCatalog.getRawJsonSchema(schemaId); + + if (rawJsonSchema.isPresent()) { + final SchemaClient schemaClient = schemaClientFactory.create(rawCatalog); + final Schema schema = jsonStringToSchemaConverter.convert(rawJsonSchema.get(), schemaClient); + return of(schema); + } + + return empty(); + } +} diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogLoader.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogLoader.java deleted file mode 100644 index 568cf43..0000000 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogLoader.java +++ /dev/null @@ -1,40 +0,0 @@ -package uk.gov.justice.schema.catalog; - -import uk.gov.justice.schema.client.SchemaClientFactory; - -import java.util.Map; - -import javax.inject.Inject; - -import org.everit.json.schema.Schema; - -public class CatalogLoader { - - private final SchemaResolverAndLoader schemaResolverAndLoader; - private final CatalogToSchemaResolver catalogToSchemaResolver; - private final JsonSchemaFileLoader jsonSchemaFileLoader; - private final SchemaClientFactory schemaClientFactory; - - @Inject - public CatalogLoader( - final SchemaResolverAndLoader schemaResolverAndLoader, - final CatalogToSchemaResolver catalogToSchemaResolver, - final JsonSchemaFileLoader jsonSchemaFileLoader, - final SchemaClientFactory schemaClientFactory) { - this.schemaResolverAndLoader = schemaResolverAndLoader; - this.catalogToSchemaResolver = catalogToSchemaResolver; - this.jsonSchemaFileLoader = jsonSchemaFileLoader; - this.schemaClientFactory = schemaClientFactory; - } - - public Map loadCatalogsFromClasspath() { - - final Map urlsToJson = jsonSchemaFileLoader.loadJsonFrom( - catalogToSchemaResolver.resolveSchemaLocations() - ); - - return schemaResolverAndLoader.loadSchemas( - urlsToJson, - schemaClientFactory.create(urlsToJson)); - } -} diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogObjectFactory.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogObjectFactory.java new file mode 100644 index 0000000..074f1c5 --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogObjectFactory.java @@ -0,0 +1,79 @@ +package uk.gov.justice.schema.catalog; + +import static org.slf4j.LoggerFactory.getLogger; + +import uk.gov.justice.schema.catalog.client.SchemaClientFactory; +import uk.gov.justice.schema.catalog.util.ClasspathResourceLoader; +import uk.gov.justice.schema.catalog.util.UriResolver; +import uk.gov.justice.schema.catalog.util.UrlConverter; +import uk.gov.justice.services.common.converter.jackson.ObjectMapperProducer; + +import com.fasterxml.jackson.databind.ObjectMapper; + +public class CatalogObjectFactory { + + public UrlConverter urlConverter() { + return new UrlConverter(); + } + + public ObjectMapper objectMapper() { + return new ObjectMapperProducer().objectMapper(); + } + + public UriResolver uriResolver() { + return new UriResolver(); + } + + public JsonStringToSchemaConverter jsonStringToSchemaConverter() { + return new JsonStringToSchemaConverter(); + } + + public ClasspathResourceLoader classpathResourceLoader() { + return new ClasspathResourceLoader(); + } + + public ClasspathCatalogLoader classpathCatalogLoader() { + return new ClasspathCatalogLoader( + objectMapper(), + classpathResourceLoader(), + urlConverter()); + } + + public SchemaResolver schemaResolver() { + return new SchemaResolver(urlConverter(), uriResolver()); + } + + public CatalogToSchemaResolver catalogToSchemaResolver() { + return new CatalogToSchemaResolver( + classpathCatalogLoader(), + schemaResolver(), + getLogger(CatalogToSchemaResolver.class)); + } + + public FileContentsAsStringLoader fileContentsAsStringLoader() { + return new FileContentsAsStringLoader(); + } + + public JsonSchemaFileLoader jsonSchemaFileLoader() { + return new JsonSchemaFileLoader(fileContentsAsStringLoader(), catalogToSchemaResolver()); + } + + public SchemaClientFactory schemaClientFactory() { + return new SchemaClientFactory(); + } + + public Catalog catalog() { + return new Catalog( + rawCatalog(), + schemaClientFactory(), + jsonStringToSchemaConverter()); + } + + public RawCatalog rawCatalog() { + final RawCatalog rawCatalog = new RawCatalog(jsonSchemaFileLoader()); + rawCatalog.initialize(); + + return rawCatalog; + } +} + diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogProducer.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogProducer.java new file mode 100644 index 0000000..147f91c --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogProducer.java @@ -0,0 +1,13 @@ +package uk.gov.justice.schema.catalog; + +import javax.enterprise.context.ApplicationScoped; +import javax.enterprise.inject.Produces; + +@ApplicationScoped +public class CatalogProducer { + + @Produces + public Catalog catalog() { + return new CatalogObjectFactory().catalog(); + } +} diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolver.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolver.java index 2f29efa..ccab859 100644 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolver.java +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolver.java @@ -13,8 +13,6 @@ import java.util.Map; import java.util.Optional; -import javax.inject.Inject; - import org.slf4j.Logger; public class CatalogToSchemaResolver { @@ -23,19 +21,15 @@ public class CatalogToSchemaResolver { private final SchemaResolver schemaResolver; private final Logger logger; - @Inject - public CatalogToSchemaResolver( - final ClasspathCatalogLoader classpathCatalogLoader, - final SchemaResolver schemaResolver, - final Logger logger) { + public CatalogToSchemaResolver(final ClasspathCatalogLoader classpathCatalogLoader, + final SchemaResolver schemaResolver, + final Logger logger) { this.classpathCatalogLoader = classpathCatalogLoader; this.schemaResolver = schemaResolver; this.logger = logger; } - /** - * * @return Mapping from schemaId to a schema location url */ public Map resolveSchemaLocations() { @@ -44,16 +38,16 @@ public Map resolveSchemaLocations() { final Map catalogs = classpathCatalogLoader.getCatalogs(); - for(final URI catalogLocation: catalogs.keySet()) { - for(final Group group: catalogs.get(catalogLocation).getGroups()) { - for(final Schema schema: group.getSchemas()) { + for (final URI catalogLocation : catalogs.keySet()) { + for (final Group group : catalogs.get(catalogLocation).getGroups()) { + for (final Schema schema : group.getSchemas()) { final String location = schema.getLocation(); final Optional baseLocation = ofNullable(group.getBaseLocation()); final String schemaId = schema.getId(); final URL schemaLocationUrl = schemaResolver.resolve(catalogLocation, location, baseLocation); - if(schemaLocations.containsKey(schemaId)) { + if (schemaLocations.containsKey(schemaId)) { final URL otherLocation = schemaLocations.get(schemaId); logger.warn(format("Found duplicate schema id '%s' for schemaLocations '%s' and '%s'", schemaId, otherLocation, schemaLocationUrl)); } else { diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/ClasspathCatalogLoader.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/ClasspathCatalogLoader.java index 48e0086..a205f26 100644 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/ClasspathCatalogLoader.java +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/ClasspathCatalogLoader.java @@ -13,8 +13,6 @@ import java.util.List; import java.util.Map; -import javax.inject.Inject; - import com.fasterxml.jackson.databind.ObjectMapper; public class ClasspathCatalogLoader { @@ -25,7 +23,6 @@ public class ClasspathCatalogLoader { private final ClasspathResourceLoader classpathResourceLoader; private final UrlConverter urlConverter; - @Inject public ClasspathCatalogLoader(final ObjectMapper objectMapper, final ClasspathResourceLoader classpathResourceLoader, final UrlConverter urlConverter) { diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoader.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoader.java index 9ca4e8b..1701446 100644 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoader.java +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoader.java @@ -2,22 +2,21 @@ import static java.util.stream.Collectors.toMap; -import java.net.URL; import java.util.Map; -import javax.inject.Inject; - public class JsonSchemaFileLoader { private final FileContentsAsStringLoader fileContentsAsStringLoader; + private final CatalogToSchemaResolver catalogToSchemaResolver; - @Inject - public JsonSchemaFileLoader(final FileContentsAsStringLoader fileContentsAsStringLoader) { + public JsonSchemaFileLoader(final FileContentsAsStringLoader fileContentsAsStringLoader, final CatalogToSchemaResolver catalogToSchemaResolver) { this.fileContentsAsStringLoader = fileContentsAsStringLoader; + this.catalogToSchemaResolver = catalogToSchemaResolver; } - public Map loadJsonFrom(final Map schemaLocationMap) { - return schemaLocationMap.entrySet() + public Map loadSchemas() { + + return catalogToSchemaResolver.resolveSchemaLocations().entrySet() .stream() .collect(toMap(Map.Entry::getKey, entry -> fileContentsAsStringLoader.readFileContents(entry.getValue()))); } diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/RawCatalog.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/RawCatalog.java new file mode 100644 index 0000000..b6ea2a0 --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/RawCatalog.java @@ -0,0 +1,26 @@ +package uk.gov.justice.schema.catalog; + +import static java.util.Optional.ofNullable; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class RawCatalog { + + private final JsonSchemaFileLoader jsonSchemaFileLoader; + + private Map schemaIdsToRawJsonSchemaCache = new HashMap<>(); + + public RawCatalog(final JsonSchemaFileLoader jsonSchemaFileLoader) { + this.jsonSchemaFileLoader = jsonSchemaFileLoader; + } + + public void initialize() { + schemaIdsToRawJsonSchemaCache = jsonSchemaFileLoader.loadSchemas(); + } + + public Optional getRawJsonSchema(final String schemaId) { + return ofNullable(schemaIdsToRawJsonSchemaCache.get(schemaId)); + } +} diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolver.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolver.java index 232214c..e7e15e9 100644 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolver.java +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolver.java @@ -10,8 +10,6 @@ import java.net.URL; import java.util.Optional; -import javax.inject.Inject; - public class SchemaResolver { private static final String AN_EMPTY_STRING = ""; @@ -19,7 +17,6 @@ public class SchemaResolver { private final UrlConverter urlConverter; private final UriResolver uriResolver; - @Inject public SchemaResolver(final UrlConverter urlConverter, final UriResolver uriResolver) { this.urlConverter = urlConverter; this.uriResolver = uriResolver; diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoader.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoader.java deleted file mode 100644 index 4f22926..0000000 --- a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoader.java +++ /dev/null @@ -1,28 +0,0 @@ -package uk.gov.justice.schema.catalog; - -import static java.util.stream.Collectors.toMap; - -import java.util.Map; - -import javax.inject.Inject; - -import org.everit.json.schema.Schema; -import org.everit.json.schema.loader.SchemaClient; - -public class SchemaResolverAndLoader { - - private final JsonStringToSchemaConverter jsonStringToSchemaConverter; - - @Inject - public SchemaResolverAndLoader(final JsonStringToSchemaConverter jsonStringToSchemaConverter) { - this.jsonStringToSchemaConverter = jsonStringToSchemaConverter; - } - - public Map loadSchemas(final Map urlsToJson, final SchemaClient schemaClient) { - - return urlsToJson.entrySet() - .stream() - .collect(toMap(Map.Entry::getKey, entry -> jsonStringToSchemaConverter.convert(entry.getValue(), schemaClient))); - } - -} diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClient.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClient.java new file mode 100644 index 0000000..9aa995a --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClient.java @@ -0,0 +1,29 @@ +package uk.gov.justice.schema.catalog.client; + +import static java.lang.String.format; +import static java.nio.charset.StandardCharsets.UTF_8; + +import uk.gov.justice.schema.catalog.RawCatalog; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; + +import org.everit.json.schema.loader.SchemaClient; + +public class LocalFileSystemSchemaClient implements SchemaClient { + + private final RawCatalog rawCatalog; + + public LocalFileSystemSchemaClient(final RawCatalog rawCatalog) { + this.rawCatalog = rawCatalog; + } + + @Override + public InputStream get(final String schemaId) { + + final String rawJsonSchema = rawCatalog.getRawJsonSchema(schemaId) + .orElseThrow(() -> new SchemaClientException(format("Failed to find schema with id '%s'", schemaId))); + + return new ByteArrayInputStream(rawJsonSchema.getBytes(UTF_8)); + } +} diff --git a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientException.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientException.java similarity index 76% rename from everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientException.java rename to catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientException.java index fe3ba6e..57f427a 100644 --- a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientException.java +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientException.java @@ -1,4 +1,4 @@ -package uk.gov.justice.schema.client; +package uk.gov.justice.schema.catalog.client; public class SchemaClientException extends RuntimeException { diff --git a/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientFactory.java b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientFactory.java new file mode 100644 index 0000000..84bac40 --- /dev/null +++ b/catalog-core/src/main/java/uk/gov/justice/schema/catalog/client/SchemaClientFactory.java @@ -0,0 +1,12 @@ +package uk.gov.justice.schema.catalog.client; + +import uk.gov.justice.schema.catalog.RawCatalog; + +import org.everit.json.schema.loader.SchemaClient; + +public class SchemaClientFactory { + + public SchemaClient create(final RawCatalog rawCatalog) { + return new LocalFileSystemSchemaClient(rawCatalog); + } +} diff --git a/catalog-core/src/main/resources/META-INF/beans.xml b/catalog-core/src/main/resources/META-INF/beans.xml index cc3f8d2..9cee431 100644 --- a/catalog-core/src/main/resources/META-INF/beans.xml +++ b/catalog-core/src/main/resources/META-INF/beans.xml @@ -2,5 +2,5 @@ + version="1.1" bean-discovery-mode="annotated"> \ No newline at end of file diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderTest.java deleted file mode 100644 index e85f090..0000000 --- a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderTest.java +++ /dev/null @@ -1,58 +0,0 @@ -package uk.gov.justice.schema.catalog; - -import static com.google.common.collect.ImmutableMap.of; -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.schema.client.LocalFileSystemSchemaClient; -import uk.gov.justice.schema.client.SchemaClientFactory; - -import java.net.URL; -import java.util.Map; - -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 CatalogLoaderTest { - - - @Mock - private SchemaResolverAndLoader schemaResolverAndLoader; - - @Mock - private CatalogToSchemaResolver catalogToSchemaResolver; - - @Mock - private JsonSchemaFileLoader jsonSchemaFileLoader; - - @Mock - private SchemaClientFactory schemaClientFactory; - - @InjectMocks - private CatalogLoader catalogLoader; - - @Test - public void shouldLoadCatalogs() throws Exception { - - final Map schemaLocationMap = of("name", new URL("file://src/main/file.txt")); - final Map urlsToJson = of("id", "{\"some\": \"json\"}"); - final Map urlsToSchema = of("id", mock(Schema.class)); - - final LocalFileSystemSchemaClient localFileSystemSchemaClient = mock(LocalFileSystemSchemaClient.class); - - when(catalogToSchemaResolver.resolveSchemaLocations()).thenReturn(schemaLocationMap); - when(jsonSchemaFileLoader.loadJsonFrom(schemaLocationMap)).thenReturn(urlsToJson); - when(schemaClientFactory.create(urlsToJson)).thenReturn(localFileSystemSchemaClient); - - when(schemaResolverAndLoader.loadSchemas(urlsToJson, localFileSystemSchemaClient)).thenReturn(urlsToSchema); - - assertThat(catalogLoader.loadCatalogsFromClasspath(), is(urlsToSchema)); - } -} diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogObjectFactoryTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogObjectFactoryTest.java new file mode 100644 index 0000000..447c4b0 --- /dev/null +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogObjectFactoryTest.java @@ -0,0 +1,162 @@ +package uk.gov.justice.schema.catalog; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.junit.Assert.assertThat; + +import uk.gov.justice.schema.catalog.client.SchemaClientFactory; +import uk.gov.justice.schema.catalog.util.ClasspathResourceLoader; +import uk.gov.justice.schema.catalog.util.UriResolver; +import uk.gov.justice.schema.catalog.util.UrlConverter; + +import java.lang.reflect.Field; +import java.util.Map; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class CatalogObjectFactoryTest { + + @InjectMocks + private CatalogObjectFactory catalogObjectFactory; + + @Test + public void shouldCreateAUrlConverter() throws Exception { + assertThat(catalogObjectFactory.urlConverter(), is(instanceOf(UrlConverter.class))); + } + + @Test + public void shouldCreateAnObjectMapper() throws Exception { + assertThat(catalogObjectFactory.objectMapper(), is(instanceOf(ObjectMapper.class))); + } + + @Test + public void shouldCreateAUriResolver() throws Exception { + + final UriResolver uriResolver = catalogObjectFactory.uriResolver(); + assertThat(uriResolver, is(notNullValue())); + } + + @Test + public void shouldCreateAJsonStringToSchemaConverter() throws Exception { + + final JsonStringToSchemaConverter jsonStringToSchemaConverter = catalogObjectFactory.jsonStringToSchemaConverter(); + assertThat(jsonStringToSchemaConverter, is(notNullValue())); + } + + @Test + public void shouldCreateAClasspathResourceLoader() throws Exception { + + final ClasspathResourceLoader classpathResourceLoader = catalogObjectFactory.classpathResourceLoader(); + assertThat(classpathResourceLoader, is(notNullValue())); + } + + @Test + public void shouldCreateAClasspathCatalogLoader() throws Exception { + + final ClasspathCatalogLoader classpathCatalogLoader = catalogObjectFactory.classpathCatalogLoader(); + assertThat(classpathCatalogLoader, is(notNullValue())); + + final ObjectMapper objectMapper = getPrivateField("objectMapper", classpathCatalogLoader, ObjectMapper.class); + assertThat(objectMapper, is(notNullValue())); + + final ClasspathResourceLoader classpathResourceLoader = getPrivateField("classpathResourceLoader", classpathCatalogLoader, ClasspathResourceLoader.class); + assertThat(classpathResourceLoader, is(notNullValue())); + + final UrlConverter urlConverter = getPrivateField("urlConverter", classpathCatalogLoader, UrlConverter.class); + assertThat(urlConverter, is(notNullValue())); + } + + @Test + public void shouldCreateASchemaResolver() throws Exception { + + final SchemaResolver schemaResolver = catalogObjectFactory.schemaResolver(); + assertThat(schemaResolver, is(notNullValue())); + + final UrlConverter urlConverter = getPrivateField("urlConverter", schemaResolver, UrlConverter.class); + assertThat(urlConverter, is(notNullValue())); + + final UriResolver uriResolver = getPrivateField("uriResolver", schemaResolver, UriResolver.class); + assertThat(uriResolver, is(notNullValue())); + } + + @Test + public void shouldCreateCatalogToSchemaResolver() throws Exception { + + final CatalogToSchemaResolver catalogToSchemaResolver = catalogObjectFactory.catalogToSchemaResolver(); + assertThat(catalogToSchemaResolver, is(notNullValue())); + + final ClasspathCatalogLoader classpathCatalogLoader = getPrivateField("classpathCatalogLoader", catalogToSchemaResolver, ClasspathCatalogLoader.class); + assertThat(classpathCatalogLoader, is(notNullValue())); + + final SchemaResolver schemaResolver = getPrivateField("schemaResolver", catalogToSchemaResolver, SchemaResolver.class); + assertThat(schemaResolver, is(notNullValue())); + } + + @Test + public void shouldCreateAFileContentsAsStringLoader() throws Exception { + + final FileContentsAsStringLoader fileContentsAsStringLoader = catalogObjectFactory.fileContentsAsStringLoader(); + assertThat(fileContentsAsStringLoader, is(notNullValue())); + } + + @Test + public void shouldCreateAJsonSchemaFileLoader() throws Exception { + + final JsonSchemaFileLoader jsonSchemaFileLoader = catalogObjectFactory.jsonSchemaFileLoader(); + assertThat(jsonSchemaFileLoader, is(notNullValue())); + + final FileContentsAsStringLoader fileContentsAsStringLoader = getPrivateField("fileContentsAsStringLoader", jsonSchemaFileLoader, FileContentsAsStringLoader.class); + assertThat(fileContentsAsStringLoader, is(notNullValue())); + } + + @Test + public void shouldCreateASchemaClientFactory() throws Exception { + + final SchemaClientFactory schemaClientFactory = catalogObjectFactory.schemaClientFactory(); + assertThat(schemaClientFactory, is(notNullValue())); + } + + @Test + public void shouldCreateRawCatalog() throws Exception { + final RawCatalog rawCatalog = catalogObjectFactory.rawCatalog(); + + assertThat(rawCatalog, is(notNullValue())); + + final JsonSchemaFileLoader jsonSchemaFileLoader = getPrivateField("jsonSchemaFileLoader", rawCatalog, JsonSchemaFileLoader.class); + assertThat(jsonSchemaFileLoader, is(notNullValue())); + + final Map schemaIdsToRawJsonSchemaCache = getPrivateField("schemaIdsToRawJsonSchemaCache", rawCatalog, Map.class); + assertThat(schemaIdsToRawJsonSchemaCache.size(), is(3)); + } + + @Test + public void shouldCreateCatalog() throws Exception { + final Catalog catalog = catalogObjectFactory.catalog(); + + assertThat(catalog, is(notNullValue())); + + final RawCatalog rawCatalog = getPrivateField("rawCatalog", catalog, RawCatalog.class); + assertThat(rawCatalog, is(notNullValue())); + + final SchemaClientFactory schemaClientFactory = getPrivateField("schemaClientFactory", catalog, SchemaClientFactory.class); + assertThat(schemaClientFactory, is(notNullValue())); + + final JsonStringToSchemaConverter jsonStringToSchemaConverter = getPrivateField("jsonStringToSchemaConverter", catalog, JsonStringToSchemaConverter.class); + assertThat(jsonStringToSchemaConverter, is(notNullValue())); + } + + @SuppressWarnings("unchecked") + private T getPrivateField(final String fieldName, final Object fromThisObject, @SuppressWarnings("unused") final Class clazz) throws Exception { + + final Field field = fromThisObject.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + + return (T) field.get(fromThisObject); + } +} diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogProducerTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogProducerTest.java new file mode 100644 index 0000000..f831b88 --- /dev/null +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogProducerTest.java @@ -0,0 +1,41 @@ +package uk.gov.justice.schema.catalog; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.junit.Assert.assertThat; + +import uk.gov.justice.schema.catalog.client.SchemaClientFactory; + +import java.lang.reflect.Field; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class CatalogProducerTest { + + @InjectMocks + private CatalogProducer catalogProducer; + + @Test + public void shouldCreateTheCatalog() throws Exception { + + final Catalog catalog = catalogProducer.catalog(); + + assertThat(catalog, is(notNullValue())); + + assertThat(getPrivateField(catalog, "rawCatalog", RawCatalog.class), is(notNullValue())); + assertThat(getPrivateField(catalog, "schemaClientFactory", SchemaClientFactory.class), is(notNullValue())); + assertThat(getPrivateField(catalog, "jsonStringToSchemaConverter", JsonStringToSchemaConverter.class), is(notNullValue())); + } + + @SuppressWarnings("unchecked") + private T getPrivateField(final Catalog catalog, final String fieldName, @SuppressWarnings("unused") final Class clazz) throws Exception { + + final Field field = catalog.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + return (T) field.get(catalog); + } +} diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogTest.java new file mode 100644 index 0000000..11ff48d --- /dev/null +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogTest.java @@ -0,0 +1,61 @@ +package uk.gov.justice.schema.catalog; + +import static java.util.Optional.empty; +import static java.util.Optional.of; +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.schema.catalog.client.SchemaClientFactory; + +import org.everit.json.schema.Schema; +import org.everit.json.schema.loader.SchemaClient; +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 CatalogTest { + + @Mock + private RawCatalog rawCatalog; + + @Mock + private SchemaClientFactory schemaClientFactory; + + @Mock + private JsonStringToSchemaConverter jsonStringToSchemaConverter; + + @InjectMocks + private Catalog catalog; + + @Test + public void shouldLoadTheRawJsonSchemaAndConvertToAFullSchemaObject() throws Exception { + + final String schemaId = "schemaId"; + final String rawJsonSchema = "raw json schema"; + + final SchemaClient schemaClient = mock(SchemaClient.class); + final Schema schema = mock(Schema.class); + + when(rawCatalog.getRawJsonSchema(schemaId)).thenReturn(of(rawJsonSchema)); + when(schemaClientFactory.create(rawCatalog)).thenReturn(schemaClient); + when(jsonStringToSchemaConverter.convert(rawJsonSchema, schemaClient)).thenReturn(schema); + + assertThat(catalog.getSchema(schemaId), is(of(schema))); + } + + @Test + public void shouldReturnEmptyIfNoRawSchemaJsonFound() throws Exception { + + final String schemaId = "schemaId"; + + when(rawCatalog.getRawJsonSchema(schemaId)).thenReturn(empty()); + + assertThat(catalog.getSchema(schemaId), is(empty())); + } +} diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolverTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolverTest.java index 011f4cb..83d6a65 100644 --- a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolverTest.java +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/CatalogToSchemaResolverTest.java @@ -10,8 +10,6 @@ import uk.gov.justice.schema.catalog.domain.Catalog; import uk.gov.justice.schema.catalog.domain.Group; import uk.gov.justice.schema.catalog.domain.Schema; -import uk.gov.justice.schema.catalog.util.UriResolver; -import uk.gov.justice.schema.catalog.util.UrlConverter; import java.net.URI; import java.net.URL; @@ -35,7 +33,7 @@ public class CatalogToSchemaResolverTest { @Spy @SuppressWarnings("unused") - private final SchemaResolver schemaResolver = new SchemaResolver(new UrlConverter(), new UriResolver()); + private final SchemaResolver schemaResolver = new CatalogObjectFactory().schemaResolver(); @Mock private Logger logger; @@ -43,6 +41,7 @@ public class CatalogToSchemaResolverTest { @InjectMocks private CatalogToSchemaResolver catalogToSchemaResolver; + @Test public void shouldMapSchemasFoundOnTheClasspathToTheirIds() throws Exception { diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoaderTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoaderTest.java index eb0827a..76800a8 100644 --- a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoaderTest.java +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/JsonSchemaFileLoaderTest.java @@ -1,5 +1,6 @@ package uk.gov.justice.schema.catalog; +import static com.google.common.collect.ImmutableMap.of; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.when; @@ -7,7 +8,6 @@ import java.net.URL; import java.util.Map; -import com.google.common.collect.ImmutableMap; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; @@ -20,11 +20,14 @@ public class JsonSchemaFileLoaderTest { @Mock private FileContentsAsStringLoader fileContentsAsStringLoader; + @Mock + private CatalogToSchemaResolver catalogToSchemaResolver; + @InjectMocks private JsonSchemaFileLoader jsonSchemaFileLoader; @Test - public void shouldName() throws Exception { + public void shouldFindAllTheSchemasThenLoadThemAsAString() throws Exception { final URL url_1 = new URL("file:/my/json/schema.json"); final URL url_2 = new URL("file:/my/other/json/schema.json"); @@ -32,12 +35,13 @@ public void shouldName() throws Exception { final String json_1 = "{\"some\": \"json\"}"; final String json_2 = "{\"other\": \"json\"}"; - final Map schemaLocationMap = ImmutableMap.of("id_1", url_1, "id_2", url_2); + final Map schemaLocationMap = of("id_1", url_1, "id_2", url_2); + when(catalogToSchemaResolver.resolveSchemaLocations()).thenReturn(schemaLocationMap); when(fileContentsAsStringLoader.readFileContents(url_1)).thenReturn(json_1); when(fileContentsAsStringLoader.readFileContents(url_2)).thenReturn(json_2); - final Map idsToJson = jsonSchemaFileLoader.loadJsonFrom(schemaLocationMap); + final Map idsToJson = jsonSchemaFileLoader.loadSchemas(); assertThat(idsToJson.get("id_1"), is(json_1)); assertThat(idsToJson.get("id_2"), is(json_2)); diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/RawCatalogTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/RawCatalogTest.java new file mode 100644 index 0000000..18b810e --- /dev/null +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/RawCatalogTest.java @@ -0,0 +1,96 @@ +package uk.gov.justice.schema.catalog; + +import static java.util.Optional.empty; +import static java.util.Optional.of; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Map; + +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 RawCatalogTest { + + @Mock + private JsonSchemaFileLoader jsonSchemaFileLoader; + + @InjectMocks + private RawCatalog rawCatalog; + + @SuppressWarnings("unchecked") + @Test + public void shouldGetRawJsonSchemaFromTheLoadedSchemaCache() throws Exception { + + final String schemaId = "schema id"; + final String rawJsonSchema = "json schema"; + + final Map schemaIdsToRawJsonSchemaCache = mock(Map.class); + + when(jsonSchemaFileLoader.loadSchemas()).thenReturn(schemaIdsToRawJsonSchemaCache); + when(schemaIdsToRawJsonSchemaCache.get(schemaId)).thenReturn(rawJsonSchema); + + rawCatalog.initialize(); + + assertThat(rawCatalog.getRawJsonSchema(schemaId), is(of(rawJsonSchema))); + } + + @SuppressWarnings("unchecked") + @Test + public void shouldReturnEmptyIfNoSchemaFound() throws Exception { + final String schemaId = "schema id"; + + final Map schemaIdsToRawJsonSchemaCache = mock(Map.class); + + when(jsonSchemaFileLoader.loadSchemas()).thenReturn(schemaIdsToRawJsonSchemaCache); + when(schemaIdsToRawJsonSchemaCache.get(schemaId)).thenReturn(null); + + rawCatalog.initialize(); + + assertThat(rawCatalog.getRawJsonSchema(schemaId), is(empty())); + } + + @Test + public void shouldCacheTheResultsOfTheCallToJsonSchemaFileLoader() throws Exception { + + final String schemaId = "schema id"; + final String rawJsonSchema = "json schema"; + + final Map schemaIdsToRawJsonSchemaCache = mock(Map.class); + + when(jsonSchemaFileLoader.loadSchemas()).thenReturn(schemaIdsToRawJsonSchemaCache); + when(schemaIdsToRawJsonSchemaCache.get(schemaId)).thenReturn(rawJsonSchema); + + rawCatalog.initialize(); + + rawCatalog.getRawJsonSchema(schemaId); + rawCatalog.getRawJsonSchema(schemaId); + rawCatalog.getRawJsonSchema(schemaId); + rawCatalog.getRawJsonSchema(schemaId); + rawCatalog.getRawJsonSchema(schemaId); + rawCatalog.getRawJsonSchema(schemaId); + + verify(jsonSchemaFileLoader, times(1)).loadSchemas(); + } + + @SuppressWarnings("unchecked") + @Test + public void shouldReturnEmptyIfTheCacheIsNotInitialized() throws Exception { + final String schemaId = "schema id"; + + final Map schemaIdsToRawJsonSchemaCache = mock(Map.class); + + when(jsonSchemaFileLoader.loadSchemas()).thenReturn(schemaIdsToRawJsonSchemaCache); + when(schemaIdsToRawJsonSchemaCache.get(schemaId)).thenReturn(null); + + assertThat(rawCatalog.getRawJsonSchema(schemaId), is(empty())); + } +} diff --git a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoaderTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoaderTest.java deleted file mode 100644 index 39762f1..0000000 --- a/catalog-core/src/test/java/uk/gov/justice/schema/catalog/SchemaResolverAndLoaderTest.java +++ /dev/null @@ -1,78 +0,0 @@ -package uk.gov.justice.schema.catalog; - -import static com.google.common.collect.ImmutableMap.of; -import static com.jayway.jsonassert.JsonAssert.with; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; - -import uk.gov.justice.schema.client.LocalFileSystemSchemaClient; - -import java.util.Map; - -import org.everit.json.schema.Schema; -import org.everit.json.schema.loader.SchemaClient; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Spy; -import org.mockito.runners.MockitoJUnitRunner; - - -@RunWith(MockitoJUnitRunner.class) -public class SchemaResolverAndLoaderTest { - - private static final String SCHEMA_1 = - "{\n" + - " \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n" + - " \"id\": \"http://justice.gov.uk/context/person.json\",\n" + - " \"type\": \"object\",\n" + - " \"properties\": {\n" + - " \"name\": {\n" + - " \"type\": \"string\"\n" + - " }\n" + - " }\n" + - "}\n"; - - private static final String SCHEMA_2 = - "{\n" + - " \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n" + - " \"id\": \"http://justice.gov.uk/context/person.json\",\n" + - " \"type\": \"object\",\n" + - " \"properties\": {\n" + - " \"age\": {\n" + - " \"type\": \"integer\"\n" + - " }\n" + - " }\n" + - "}\n"; - - @Spy @SuppressWarnings("unused") - private final JsonStringToSchemaConverter jsonStringToSchemaConverter = new JsonStringToSchemaConverter(); - - @InjectMocks - private SchemaResolverAndLoader schemaResolverAndLoader; - - @Test - public void shouldLoadSchemasAndMapByTheirIdsIntoTheSchemaDictonary() throws Exception { - - final String id_1 = "id_1"; - final String id_2 = "id_2"; - final Map idsToJson = of(id_1, SCHEMA_1, id_2, SCHEMA_2); - - final SchemaClient schemaClient = new LocalFileSystemSchemaClient(idsToJson); - - final Map idToSchemaMap = schemaResolverAndLoader.loadSchemas(idsToJson, schemaClient); - - assertThat(idToSchemaMap.size(), is(2)); - - final Schema schema_1 = idToSchemaMap.get(id_1); - final Schema schema_2 = idToSchemaMap.get(id_2); - - with(schema_1.toString()) - .assertThat("$.properties.name.type", is("string")) - ; - - with(schema_2.toString()) - .assertThat("$.properties.age.type", is("integer")) - ; - } -} diff --git a/everit-schema-client/src/test/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClientTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClientTest.java similarity index 51% rename from everit-schema-client/src/test/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClientTest.java rename to catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClientTest.java index 3557c95..23fac67 100644 --- a/everit-schema-client/src/test/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClientTest.java +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/LocalFileSystemSchemaClientTest.java @@ -1,29 +1,43 @@ -package uk.gov.justice.schema.client; +package uk.gov.justice.schema.catalog.client; -import static com.google.common.collect.ImmutableMap.of; import static com.jayway.jsonassert.JsonAssert.with; import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Optional.empty; +import static java.util.Optional.of; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; +import static org.mockito.Mockito.when; + +import uk.gov.justice.schema.catalog.RawCatalog; import java.io.InputStream; -import java.util.HashMap; -import java.util.Map; import org.apache.commons.io.IOUtils; 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 LocalFileSystemSchemaClientTest { + @Mock + private RawCatalog rawCatalog; + + @InjectMocks + private LocalFileSystemSchemaClient localFileSystemSchemaClient; + @Test public void shouldFindSchemaJsonByItsUrlIdAndReturnAsAnInputStream() throws Exception { - final Map urlsToJson = of("url", "{\"some\": \"json\"}"); + final String schemaId = "schemaId"; + final String rawJsonSchema = "{\"some\": \"json\"}"; - final LocalFileSystemSchemaClient localFileSystemSchemaClient = new LocalFileSystemSchemaClient(urlsToJson); + when(rawCatalog.getRawJsonSchema(schemaId)).thenReturn(of(rawJsonSchema)); - final InputStream inputStream = localFileSystemSchemaClient.get("url"); + final InputStream inputStream = localFileSystemSchemaClient.get(schemaId); final String json = IOUtils.toString(inputStream, UTF_8); @@ -37,17 +51,15 @@ public void shouldFindSchemaJsonByItsUrlIdAndReturnAsAnInputStream() throws Exce @Test public void shouldFailIfNoSchemaFoundForTheUrlId() throws Exception { - final String url = "file:/some/url/or/other"; - - final Map urlsToJson = new HashMap<>(); + final String schemaId = "schemaId"; - final LocalFileSystemSchemaClient localFileSystemSchemaClient = new LocalFileSystemSchemaClient(urlsToJson); + when(rawCatalog.getRawJsonSchema(schemaId)).thenReturn(empty()); try { - localFileSystemSchemaClient.get(url); + localFileSystemSchemaClient.get(schemaId); fail(); } catch (final SchemaClientException expected) { - assertThat(expected.getMessage(), is("Failed to find schema with id 'file:/some/url/or/other'")); + assertThat(expected.getMessage(), is("Failed to find schema with id 'schemaId'")); } } } diff --git a/everit-schema-client/src/test/java/uk/gov/justice/schema/client/SchemaClientFactoryTest.java b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/SchemaClientFactoryTest.java similarity index 64% rename from everit-schema-client/src/test/java/uk/gov/justice/schema/client/SchemaClientFactoryTest.java rename to catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/SchemaClientFactoryTest.java index 9e5dd59..c5ddeb5 100644 --- a/everit-schema-client/src/test/java/uk/gov/justice/schema/client/SchemaClientFactoryTest.java +++ b/catalog-core/src/test/java/uk/gov/justice/schema/catalog/client/SchemaClientFactoryTest.java @@ -1,12 +1,13 @@ -package uk.gov.justice.schema.client; +package uk.gov.justice.schema.catalog.client; -import static com.google.common.collect.ImmutableMap.of; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.mock; + +import uk.gov.justice.schema.catalog.RawCatalog; import java.lang.reflect.Field; -import java.util.Map; import org.everit.json.schema.loader.SchemaClient; import org.junit.Test; @@ -23,15 +24,15 @@ public class SchemaClientFactoryTest { @Test public void shouldCreateANewLocalFileSystemSchemaClient() throws Exception { - final Map urlsToJson = of("id", "{\"some\": \"json\"}"); + final RawCatalog rawCatalog = mock(RawCatalog.class); - final SchemaClient schemaClient = schemaClientFactory.create(urlsToJson); + final SchemaClient schemaClient = schemaClientFactory.create(rawCatalog); assertThat(schemaClient, is(instanceOf(LocalFileSystemSchemaClient.class))); - final Field idsToJsonField = schemaClient.getClass().getDeclaredField("urlsToJson"); - idsToJsonField.setAccessible(true); + final Field rawCatalogField = schemaClient.getClass().getDeclaredField("rawCatalog"); + rawCatalogField.setAccessible(true); - assertThat(idsToJsonField.get(schemaClient), is(urlsToJson)); + assertThat(rawCatalogField.get(schemaClient), is(rawCatalog)); } } diff --git a/catalog-generation-plugin-it/pom.xml b/catalog-generation-plugin-it/pom.xml index a87114f..d2ae609 100644 --- a/catalog-generation-plugin-it/pom.xml +++ b/catalog-generation-plugin-it/pom.xml @@ -27,7 +27,6 @@ uk.gov.justice.schema.catalog.generation.io.parser.ListOfUriParser - uk.gov.justice.events.pojo ${basedir}/src/raml/json/schema ${project.build.directory}/generated-resources diff --git a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactory.java b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactory.java new file mode 100644 index 0000000..e62833d --- /dev/null +++ b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactory.java @@ -0,0 +1,33 @@ +package uk.gov.justice.schema.catalog.generation; + +import uk.gov.justice.schema.catalog.CatalogObjectFactory; + +public class GenerationObjectFactory extends CatalogObjectFactory { + + public CatalogGenerationContext catalogGenerationContext() { + return new CatalogGenerationContext(); + } + + public CatalogWriter catalogWriter() { + return new CatalogWriter(objectMapper(), catalogGenerationContext()); + } + + public SchemaIdParser schemaIdParser() { + return new SchemaIdParser(urlConverter()); + } + + public CatalogObjectGenerator catalogObjectGenerator() { + return new CatalogObjectGenerator(schemaDefParser()); + } + + public SchemaDefParser schemaDefParser() { + return new SchemaDefParser(schemaIdParser()); + } + + public CatalogGenerationRunner catalogGenerationRunner() { + return new CatalogGenerationRunner( + catalogObjectGenerator(), + catalogWriter(), + urlConverter()); + } +} diff --git a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/ObjectFactory.java b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/ObjectFactory.java deleted file mode 100644 index 98c36f2..0000000 --- a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/ObjectFactory.java +++ /dev/null @@ -1,107 +0,0 @@ -package uk.gov.justice.schema.catalog.generation; - -import uk.gov.justice.schema.catalog.CatalogLoader; -import uk.gov.justice.schema.catalog.CatalogToSchemaResolver; -import uk.gov.justice.schema.catalog.ClasspathCatalogLoader; -import uk.gov.justice.schema.catalog.FileContentsAsStringLoader; -import uk.gov.justice.schema.catalog.JsonSchemaFileLoader; -import uk.gov.justice.schema.catalog.JsonStringToSchemaConverter; -import uk.gov.justice.schema.catalog.SchemaResolver; -import uk.gov.justice.schema.catalog.SchemaResolverAndLoader; -import uk.gov.justice.schema.catalog.util.ClasspathResourceLoader; -import uk.gov.justice.schema.catalog.util.UriResolver; -import uk.gov.justice.schema.catalog.util.UrlConverter; -import uk.gov.justice.schema.client.SchemaClientFactory; -import uk.gov.justice.services.common.converter.jackson.ObjectMapperProducer; - -import com.fasterxml.jackson.databind.ObjectMapper; -import org.slf4j.LoggerFactory; - -public class ObjectFactory { - - public CatalogGenerationContext catalogGenerationConstants() { - return new CatalogGenerationContext(); - } - - public UrlConverter urlConverter() { - return new UrlConverter(); - } - - public ObjectMapper objectMapper() { - return new ObjectMapperProducer().objectMapper(); - } - - public CatalogWriter catalogWriter() { - return new CatalogWriter(objectMapper(), catalogGenerationConstants()); - } - - public SchemaIdParser schemaIdParser() { - return new SchemaIdParser(urlConverter()); - } - - public CatalogObjectGenerator catalogObjectGenerator() { - return new CatalogObjectGenerator(schemaDefParser()); - } - - public SchemaDefParser schemaDefParser() { - return new SchemaDefParser(schemaIdParser()); - } - - public CatalogGenerationRunner catalogGenerationRunner() { - return new CatalogGenerationRunner( - catalogObjectGenerator(), - catalogWriter(), - urlConverter()); - } - - public UriResolver uriResolver() { - return new UriResolver(); - } - - public JsonStringToSchemaConverter jsonStringToSchemaConverter() { - return new JsonStringToSchemaConverter(); - } - - public ClasspathResourceLoader classpathResourceLoader() { - return new ClasspathResourceLoader(); - } - - public SchemaResolverAndLoader schemaResolverAndLoader() { - return new SchemaResolverAndLoader(jsonStringToSchemaConverter()); - } - - public ClasspathCatalogLoader classpathCatalogLoader() { - return new ClasspathCatalogLoader( - objectMapper(), - classpathResourceLoader(), - urlConverter()); - } - - public SchemaResolver schemaResolver() { - return new SchemaResolver(urlConverter(), uriResolver()); - } - - public CatalogToSchemaResolver catalogToSchemaResolver() { - return new CatalogToSchemaResolver(classpathCatalogLoader(), schemaResolver(), LoggerFactory.getLogger(CatalogToSchemaResolver.class)); - } - - public FileContentsAsStringLoader fileContentsAsStringLoader() { - return new FileContentsAsStringLoader(); - } - - public JsonSchemaFileLoader jsonSchemaFileLoader() { - return new JsonSchemaFileLoader(fileContentsAsStringLoader()); - } - - public SchemaClientFactory schemaClientFactory() { - return new SchemaClientFactory(); - } - - public CatalogLoader catalogLoader() { - return new CatalogLoader( - schemaResolverAndLoader(), - catalogToSchemaResolver(), - jsonSchemaFileLoader(), - schemaClientFactory()); - } -} diff --git a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGenerator.java b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGenerator.java index dba72ce..eb0ea1a 100644 --- a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGenerator.java +++ b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGenerator.java @@ -3,7 +3,7 @@ import uk.gov.justice.maven.generator.io.files.parser.core.Generator; import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorConfig; import uk.gov.justice.schema.catalog.generation.CatalogGenerationRunner; -import uk.gov.justice.schema.catalog.generation.ObjectFactory; +import uk.gov.justice.schema.catalog.generation.GenerationObjectFactory; import java.net.URI; import java.nio.file.Path; @@ -11,10 +11,10 @@ public class MavenCatalogGenerator implements Generator> { - private final ObjectFactory objectFactory; + private final GenerationObjectFactory generationObjectFactory; - public MavenCatalogGenerator(final ObjectFactory objectFactory) { - this.objectFactory = objectFactory; + public MavenCatalogGenerator(final GenerationObjectFactory generationObjectFactory) { + this.generationObjectFactory = generationObjectFactory; } @Override @@ -22,7 +22,7 @@ public void run(final List schemaFiles, final GeneratorConfig generatorConf final Path catalogGenerationPath = generatorConfig.getOutputDirectory(); - final CatalogGenerationRunner catalogGenerationRunner = objectFactory.catalogGenerationRunner(); + final CatalogGenerationRunner catalogGenerationRunner = generationObjectFactory.catalogGenerationRunner(); final CatalogGeneratorProperties generatorProperties = (CatalogGeneratorProperties) generatorConfig.getGeneratorProperties(); diff --git a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorFactory.java b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorFactory.java index 371e0b2..aefc2fb 100644 --- a/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorFactory.java +++ b/catalog-generation/src/main/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorFactory.java @@ -2,7 +2,7 @@ import uk.gov.justice.maven.generator.io.files.parser.core.Generator; import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorFactory; -import uk.gov.justice.schema.catalog.generation.ObjectFactory; +import uk.gov.justice.schema.catalog.generation.GenerationObjectFactory; import java.net.URI; import java.util.List; @@ -11,6 +11,6 @@ public class MavenCatalogGeneratorFactory implements GeneratorFactory> @Override public Generator> create() { - return new MavenCatalogGenerator(new ObjectFactory()); + return new MavenCatalogGenerator(new GenerationObjectFactory()); } } diff --git a/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactoryTest.java b/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactoryTest.java new file mode 100644 index 0000000..417a506 --- /dev/null +++ b/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/GenerationObjectFactoryTest.java @@ -0,0 +1,86 @@ +package uk.gov.justice.schema.catalog.generation; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.junit.Assert.assertThat; + +import uk.gov.justice.schema.catalog.util.UrlConverter; + +import java.lang.reflect.Field; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.runners.MockitoJUnitRunner; + + +@RunWith(MockitoJUnitRunner.class) +public class GenerationObjectFactoryTest { + + + @InjectMocks + private GenerationObjectFactory generationObjectFactory; + + @Test + public void shouldCreateACatalogGenerationContext() throws Exception { + assertThat(generationObjectFactory.catalogGenerationContext(), is(instanceOf(CatalogGenerationContext.class))); + } + + @Test + public void shouldCreateACatalogWriter() throws Exception { + final CatalogWriter catalogWriter = generationObjectFactory.catalogWriter(); + assertThat(catalogWriter, is(instanceOf(CatalogWriter.class))); + + assertThat(getPrivateField("objectMapper", catalogWriter, ObjectMapper.class), is(notNullValue())); + assertThat(getPrivateField("catalogGenerationContext", catalogWriter, CatalogGenerationContext.class), is(notNullValue())); + } + + @Test + public void shouldCreateASchemaIdParser() throws Exception { + final SchemaIdParser schemaIdParser = generationObjectFactory.schemaIdParser(); + assertThat(schemaIdParser, is(instanceOf(SchemaIdParser.class))); + + assertThat(getPrivateField("urlConverter", schemaIdParser, UrlConverter.class), is(notNullValue())); + } + + @Test + public void shouldCreateACatalogObjectGenerator() throws Exception { + final CatalogObjectGenerator catalogObjectGenerator = generationObjectFactory.catalogObjectGenerator(); + assertThat(catalogObjectGenerator, is(instanceOf(CatalogObjectGenerator.class))); + + assertThat(getPrivateField("schemaDefParser", catalogObjectGenerator, SchemaDefParser.class), is(notNullValue())); + } + + @Test + public void shouldCreateASchemaDefParser() throws Exception { + final SchemaDefParser schemaDefParser = generationObjectFactory.schemaDefParser(); + assertThat(schemaDefParser, is(instanceOf(SchemaDefParser.class))); + + assertThat(getPrivateField("schemaIdParser", schemaDefParser, SchemaIdParser.class), is(notNullValue())); + } + + @Test + public void shouldCreateACatalogGenerationRunner() throws Exception { + final CatalogGenerationRunner catalogGenerationRunner = generationObjectFactory.catalogGenerationRunner(); + assertThat(catalogGenerationRunner, is(instanceOf(CatalogGenerationRunner.class))); + + assertThat(getPrivateField("catalogObjectGenerator", catalogGenerationRunner, CatalogObjectGenerator.class), is(notNullValue())); + assertThat(getPrivateField("catalogWriter", catalogGenerationRunner, CatalogWriter.class), is(notNullValue())); + assertThat(getPrivateField("urlConverter", catalogGenerationRunner, UrlConverter.class), is(notNullValue())); + } + + + + + + @SuppressWarnings("unchecked") + private T getPrivateField(final String fieldName, final Object fromThisObject, @SuppressWarnings("unused") final Class clazz) throws Exception { + + final Field field = fromThisObject.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + + return (T) field.get(fromThisObject); + } +} diff --git a/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/ObjectFactoryTest.java b/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/ObjectFactoryTest.java deleted file mode 100644 index 6b932ae..0000000 --- a/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/ObjectFactoryTest.java +++ /dev/null @@ -1,230 +0,0 @@ -package uk.gov.justice.schema.catalog.generation; - -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; - -import uk.gov.justice.schema.catalog.CatalogLoader; -import uk.gov.justice.schema.catalog.CatalogToSchemaResolver; -import uk.gov.justice.schema.catalog.ClasspathCatalogLoader; -import uk.gov.justice.schema.catalog.FileContentsAsStringLoader; -import uk.gov.justice.schema.catalog.JsonSchemaFileLoader; -import uk.gov.justice.schema.catalog.JsonStringToSchemaConverter; -import uk.gov.justice.schema.catalog.SchemaResolver; -import uk.gov.justice.schema.catalog.SchemaResolverAndLoader; -import uk.gov.justice.schema.catalog.util.ClasspathResourceLoader; -import uk.gov.justice.schema.catalog.util.UriResolver; -import uk.gov.justice.schema.catalog.util.UrlConverter; -import uk.gov.justice.schema.client.SchemaClientFactory; - -import java.lang.reflect.Field; - -import com.fasterxml.jackson.databind.ObjectMapper; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.runners.MockitoJUnitRunner; - -@RunWith(MockitoJUnitRunner.class) -public class ObjectFactoryTest { - - @InjectMocks - private ObjectFactory objectFactory; - - @Test - public void shouldCreateACatalogGenerationContext() throws Exception { - assertThat(objectFactory.catalogGenerationConstants(), is(instanceOf(CatalogGenerationContext.class))); - } - - @Test - public void shouldCreateAUrlConverter() throws Exception { - assertThat(objectFactory.urlConverter(), is(instanceOf(UrlConverter.class))); - } - - @Test - public void shouldCreateAnObjectMapper() throws Exception { - assertThat(objectFactory.objectMapper(), is(instanceOf(ObjectMapper.class))); - } - - @Test - public void shouldCreateACatalogWriter() throws Exception { - - final CatalogWriter catalogWriter = objectFactory.catalogWriter(); - assertThat(catalogWriter, is(notNullValue())); - - final ObjectMapper objectMapper = getPrivateField("objectMapper", catalogWriter, ObjectMapper.class); - assertThat(objectMapper, is(notNullValue())); - } - - @Test - public void shouldCreateASchemaIdParser() throws Exception { - - final SchemaIdParser schemaIdParser = objectFactory.schemaIdParser(); - assertThat(schemaIdParser, is(notNullValue())); - - final UrlConverter urlConverter = getPrivateField("urlConverter", schemaIdParser, UrlConverter.class); - assertThat(urlConverter, is(notNullValue())); - } - - @Test - public void shouldCreateACatalogObjectGenerator() throws Exception { - - final CatalogObjectGenerator catalogObjectGenerator = objectFactory.catalogObjectGenerator(); - assertThat(catalogObjectGenerator, is(notNullValue())); - - final SchemaDefParser schemaDefParser = getPrivateField("schemaDefParser", catalogObjectGenerator, SchemaDefParser.class); - assertThat(schemaDefParser, is(notNullValue())); - } - - @Test - public void shouldCreateASchemaDefParser() throws Exception { - - final SchemaDefParser schemaDefParser = objectFactory.schemaDefParser(); - assertThat(schemaDefParser, is(notNullValue())); - - final SchemaIdParser schemaIdParser = getPrivateField("schemaIdParser", schemaDefParser, SchemaIdParser.class); - assertThat(schemaIdParser, is(notNullValue())); - } - - @Test - public void shouldCreateACatalogGenerationRunner() throws Exception { - - final CatalogGenerationRunner catalogGenerationRunner = objectFactory.catalogGenerationRunner(); - assertThat(catalogGenerationRunner, is(notNullValue())); - - final CatalogObjectGenerator catalogObjectGenerator = getPrivateField("catalogObjectGenerator", catalogGenerationRunner, CatalogObjectGenerator.class); - assertThat(catalogObjectGenerator, is(notNullValue())); - - final CatalogWriter catalogWriter = getPrivateField("catalogWriter", catalogGenerationRunner, CatalogWriter.class); - assertThat(catalogWriter, is(notNullValue())); - - final UrlConverter urlConverter = getPrivateField("urlConverter", catalogGenerationRunner, UrlConverter.class); - assertThat(urlConverter, is(notNullValue())); - } - - @Test - public void shouldCreateAUriResolver() throws Exception { - - final UriResolver uriResolver = objectFactory.uriResolver(); - assertThat(uriResolver, is(notNullValue())); - } - - @Test - public void shouldCreateAJsonStringToSchemaConverter() throws Exception { - - final JsonStringToSchemaConverter jsonStringToSchemaConverter = objectFactory.jsonStringToSchemaConverter(); - assertThat(jsonStringToSchemaConverter, is(notNullValue())); - } - - @Test - public void shouldCreateAClasspathResourceLoader() throws Exception { - - final ClasspathResourceLoader classpathResourceLoader = objectFactory.classpathResourceLoader(); - assertThat(classpathResourceLoader, is(notNullValue())); - } - - @Test - public void shouldCreateASchemaResolverAndLoader() throws Exception { - - final SchemaResolverAndLoader schemaResolverAndLoader = objectFactory.schemaResolverAndLoader(); - assertThat(schemaResolverAndLoader, is(notNullValue())); - - final JsonStringToSchemaConverter jsonStringToSchemaConverter = getPrivateField("jsonStringToSchemaConverter", schemaResolverAndLoader, JsonStringToSchemaConverter.class); - assertThat(jsonStringToSchemaConverter, is(notNullValue())); - } - - @Test - public void shouldCreateAClasspathCatalogLoader() throws Exception { - - final ClasspathCatalogLoader classpathCatalogLoader = objectFactory.classpathCatalogLoader(); - assertThat(classpathCatalogLoader, is(notNullValue())); - - final ObjectMapper objectMapper = getPrivateField("objectMapper", classpathCatalogLoader, ObjectMapper.class); - assertThat(objectMapper, is(notNullValue())); - - final ClasspathResourceLoader classpathResourceLoader = getPrivateField("classpathResourceLoader", classpathCatalogLoader, ClasspathResourceLoader.class); - assertThat(classpathResourceLoader, is(notNullValue())); - - final UrlConverter urlConverter = getPrivateField("urlConverter", classpathCatalogLoader, UrlConverter.class); - assertThat(urlConverter, is(notNullValue())); - } - - @Test - public void shouldCreateASchemaResolver() throws Exception { - - final SchemaResolver schemaResolver = objectFactory.schemaResolver(); - assertThat(schemaResolver, is(notNullValue())); - - final UrlConverter urlConverter = getPrivateField("urlConverter", schemaResolver, UrlConverter.class); - assertThat(urlConverter, is(notNullValue())); - - final UriResolver uriResolver = getPrivateField("uriResolver", schemaResolver, UriResolver.class); - assertThat(uriResolver, is(notNullValue())); - } - - @Test - public void shouldCreateCatalogToSchemaResolver() throws Exception { - - final CatalogToSchemaResolver catalogToSchemaResolver = objectFactory.catalogToSchemaResolver(); - assertThat(catalogToSchemaResolver, is(notNullValue())); - - final ClasspathCatalogLoader classpathCatalogLoader = getPrivateField("classpathCatalogLoader", catalogToSchemaResolver, ClasspathCatalogLoader.class); - assertThat(classpathCatalogLoader, is(notNullValue())); - - final SchemaResolver schemaResolver = getPrivateField("schemaResolver", catalogToSchemaResolver, SchemaResolver.class); - assertThat(schemaResolver, is(notNullValue())); - } - - @Test - public void shouldCreateAFileContentsAsStringLoader() throws Exception { - - final FileContentsAsStringLoader fileContentsAsStringLoader = objectFactory.fileContentsAsStringLoader(); - assertThat(fileContentsAsStringLoader, is(notNullValue())); - } - - @Test - public void shouldCreateAJsonSchemaFileLoader() throws Exception { - - final JsonSchemaFileLoader jsonSchemaFileLoader = objectFactory.jsonSchemaFileLoader(); - assertThat(jsonSchemaFileLoader, is(notNullValue())); - - final FileContentsAsStringLoader fileContentsAsStringLoader = getPrivateField("fileContentsAsStringLoader", jsonSchemaFileLoader, FileContentsAsStringLoader.class); - assertThat(fileContentsAsStringLoader, is(notNullValue())); - } - - @Test - public void shouldCreateASchemaClientFactory() throws Exception { - - final SchemaClientFactory schemaClientFactory = objectFactory.schemaClientFactory(); - assertThat(schemaClientFactory, is(notNullValue())); - } - - @Test - public void shouldCreateACatalogLoader() throws Exception { - - final CatalogLoader catalogLoader = objectFactory.catalogLoader(); - assertThat(catalogLoader, is(notNullValue())); - - final SchemaResolverAndLoader schemaResolverAndLoader = getPrivateField("schemaResolverAndLoader", catalogLoader, SchemaResolverAndLoader.class); - assertThat(schemaResolverAndLoader, is(notNullValue())); - - final CatalogToSchemaResolver catalogToSchemaResolver = getPrivateField("catalogToSchemaResolver", catalogLoader, CatalogToSchemaResolver.class); - assertThat(catalogToSchemaResolver, is(notNullValue())); - - final JsonSchemaFileLoader jsonSchemaFileLoader = getPrivateField("jsonSchemaFileLoader", catalogLoader, JsonSchemaFileLoader.class); - assertThat(jsonSchemaFileLoader, is(notNullValue())); - - final SchemaClientFactory schemaClientFactory = getPrivateField("schemaClientFactory", catalogLoader, SchemaClientFactory.class); - assertThat(schemaClientFactory, is(notNullValue())); - } - - @SuppressWarnings("unchecked") - private T getPrivateField(final String fieldName, final Object fromThisObject, @SuppressWarnings("unused") final Class clazz) throws Exception { - - final Field field = fromThisObject.getClass().getDeclaredField(fieldName); - field.setAccessible(true); - - return (T) field.get(fromThisObject); - } -} diff --git a/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorTest.java b/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorTest.java index bc45f06..dce5a5c 100644 --- a/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorTest.java +++ b/catalog-generation/src/test/java/uk/gov/justice/schema/catalog/generation/maven/MavenCatalogGeneratorTest.java @@ -7,7 +7,7 @@ import uk.gov.justice.maven.generator.io.files.parser.core.GeneratorConfig; import uk.gov.justice.schema.catalog.generation.CatalogGenerationRunner; -import uk.gov.justice.schema.catalog.generation.ObjectFactory; +import uk.gov.justice.schema.catalog.generation.GenerationObjectFactory; import java.net.URI; import java.nio.file.Path; @@ -24,7 +24,7 @@ public class MavenCatalogGeneratorTest { @Mock - private ObjectFactory objectFactory; + private GenerationObjectFactory generationObjectFactory; @InjectMocks private MavenCatalogGenerator mavenCatalogGenerator; @@ -42,7 +42,7 @@ public void shouldInstantiateAndRunTheCatalogGeneration() throws Exception { final CatalogGeneratorProperties catalogGeneratorProperties = mock(CatalogGeneratorProperties.class); when(generatorConfig.getOutputDirectory()).thenReturn(catalogGenerationPath); - when(objectFactory.catalogGenerationRunner()).thenReturn(catalogGenerationRunner); + when(generationObjectFactory.catalogGenerationRunner()).thenReturn(catalogGenerationRunner); when(generatorConfig.getGeneratorProperties()).thenReturn(catalogGeneratorProperties); when(catalogGeneratorProperties.getCatalogName()).thenReturn(catalogName); when(catalogGeneratorProperties.getJsonSchemaPath()).thenReturn(jsonSchemaPath); diff --git a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClient.java b/everit-schema-client/src/main/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClient.java deleted file mode 100644 index cb27b97..0000000 --- a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/LocalFileSystemSchemaClient.java +++ /dev/null @@ -1,29 +0,0 @@ -package uk.gov.justice.schema.client; - -import static java.lang.String.format; -import static java.nio.charset.StandardCharsets.UTF_8; - -import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.util.Map; - -import org.everit.json.schema.loader.SchemaClient; - -public class LocalFileSystemSchemaClient implements SchemaClient { - - private final Map urlsToJson; - - public LocalFileSystemSchemaClient(final Map urlsToJson) { - this.urlsToJson = urlsToJson; - } - - @Override - public InputStream get(final String url) { - - if (urlsToJson.containsKey(url)) { - return new ByteArrayInputStream(urlsToJson.get(url).getBytes(UTF_8)); - } - - throw new SchemaClientException(format("Failed to find schema with id '%s'", url)); - } -} diff --git a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientFactory.java b/everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientFactory.java deleted file mode 100644 index 924087b..0000000 --- a/everit-schema-client/src/main/java/uk/gov/justice/schema/client/SchemaClientFactory.java +++ /dev/null @@ -1,12 +0,0 @@ -package uk.gov.justice.schema.client; - -import java.util.Map; - -import org.everit.json.schema.loader.SchemaClient; - -public class SchemaClientFactory { - - public SchemaClient create(final Map urlsToJson) { - return new LocalFileSystemSchemaClient(urlsToJson); - } -} diff --git a/integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderIT.java b/integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogIT.java similarity index 71% rename from integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderIT.java rename to integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogIT.java index c3e91bb..b972082 100644 --- a/integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogLoaderIT.java +++ b/integration-test/src/test/java/uk/gov/justice/schema/catalog/CatalogIT.java @@ -2,28 +2,18 @@ import static com.jayway.jsonassert.JsonAssert.with; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import uk.gov.justice.schema.catalog.generation.ObjectFactory; - -import java.util.Map; - -import org.everit.json.schema.Schema; import org.junit.Test; -public class CatalogLoaderIT { +public class CatalogIT { - private final CatalogLoader catalogLoader = new ObjectFactory().catalogLoader(); + private final Catalog catalog = new CatalogObjectFactory().catalog(); @Test public void shouldMapSchemasOnClasspathToTheirIds() throws Exception { - final Map idsToSchemaMap = catalogLoader.loadCatalogsFromClasspath(); - - assertThat(idsToSchemaMap.size(), is(3)); - final String id_1 = "http://justice.gov.uk/standards/address.json"; - final String json_1 = idsToSchemaMap.get(id_1).toString(); + final String json_1 = catalog.getSchema(id_1).get().toString(); with(json_1) .assertThat("$.id", is(id_1)) @@ -35,7 +25,7 @@ public void shouldMapSchemasOnClasspathToTheirIds() throws Exception { ; final String id_2 = "http://justice.gov.uk/context/person.json"; - final String json_2 = idsToSchemaMap.get(id_2).toString(); + final String json_2 = catalog.getSchema(id_2).get().toString(); with(json_2) .assertThat("$.id", is(id_2)) @@ -46,7 +36,7 @@ public void shouldMapSchemasOnClasspathToTheirIds() throws Exception { ; final String id_3 = "http://justice.gov.uk/standards/complex_address.json"; - final String json_3 = idsToSchemaMap.get(id_3).toString(); + final String json_3 = catalog.getSchema(id_3).get().toString(); with(json_3) .assertThat("$.id", is(id_3)) diff --git a/pom.xml b/pom.xml index 15221ba..eed1fe6 100644 --- a/pom.xml +++ b/pom.xml @@ -30,7 +30,7 @@ json-schema-catalog 1.21.0 1.10.0 - 2.2.0 + 2.3.0 diff --git a/schema-example-context/example-integration-test/src/test/java/uk/gov/justice/schema/catalog/ExampleCatalogLoaderIT.java b/schema-example-context/example-integration-test/src/test/java/uk/gov/justice/schema/catalog/ExampleCatalogLoaderIT.java index 9a8b463..4f38a02 100644 --- a/schema-example-context/example-integration-test/src/test/java/uk/gov/justice/schema/catalog/ExampleCatalogLoaderIT.java +++ b/schema-example-context/example-integration-test/src/test/java/uk/gov/justice/schema/catalog/ExampleCatalogLoaderIT.java @@ -1,30 +1,18 @@ package uk.gov.justice.schema.catalog; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; - -import uk.gov.justice.schema.catalog.generation.ObjectFactory; - -import java.util.Map; - -import org.everit.json.schema.Schema; import org.junit.Test; public class ExampleCatalogLoaderIT { - private final CatalogLoader catalogLoader = new ObjectFactory().catalogLoader(); + private final Catalog catalog = new CatalogObjectFactory().catalog(); @Test public void shouldMapSchemasOnClasspathToTheirIds2() throws Exception { - final Map idsToSchemaMap = catalogLoader.loadCatalogsFromClasspath(); - - assertThat(idsToSchemaMap.size(), is(2)); - final String id_1 = "http://justice.gov.uk/example/standard/ingredient.json"; - final String json_1 = idsToSchemaMap.get(id_1).toString(); + final String json_1 = catalog.getSchema(id_1).get().toString(); final String id_2 = "http://justice.gov.uk/example/cakeshop/example.add-recipe.json"; - final String json_2 = idsToSchemaMap.get(id_2).toString(); + final String json_2 = catalog.getSchema(id_2).get().toString(); } } diff --git a/schema-service/src/main/java/uk/gov/justice/schema/service/SchemaCatalogService.java b/schema-service/src/main/java/uk/gov/justice/schema/service/SchemaCatalogService.java index 2d4ff82..9adc0d3 100644 --- a/schema-service/src/main/java/uk/gov/justice/schema/service/SchemaCatalogService.java +++ b/schema-service/src/main/java/uk/gov/justice/schema/service/SchemaCatalogService.java @@ -1,11 +1,11 @@ package uk.gov.justice.schema.service; -import uk.gov.justice.schema.catalog.CatalogLoader; +import uk.gov.justice.schema.catalog.Catalog; import java.util.Map; import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; -import javax.annotation.PostConstruct; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; @@ -14,17 +14,21 @@ @ApplicationScoped public class SchemaCatalogService { + private final Map> schemaMap = new ConcurrentHashMap<>(); + @Inject - private CatalogLoader catalogLoader; + private Catalog catalog; - private Map catalog; + public Optional findSchema(final String schemaId) { - @PostConstruct - public void initialiseCatalog() { - catalog = catalogLoader.loadCatalogsFromClasspath(); - } + if(schemaMap.containsKey(schemaId)) { + return schemaMap.get(schemaId); + } + + final Optional schema = catalog.getSchema(schemaId); + + schemaMap.put(schemaId, schema); - public Optional findSchema(final String uri) { - return Optional.ofNullable(catalog.get(uri)); + return schema; } } diff --git a/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaCatalogServiceTest.java b/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaCatalogServiceTest.java index c187758..6a4d584 100644 --- a/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaCatalogServiceTest.java +++ b/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaCatalogServiceTest.java @@ -2,22 +2,22 @@ import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import uk.gov.justice.schema.catalog.CatalogLoader; +import uk.gov.justice.schema.catalog.Catalog; -import java.util.Map; import java.util.Optional; -import com.google.common.collect.ImmutableMap; import org.everit.json.schema.Schema; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; +@SuppressWarnings("ConstantConditions") @RunWith(MockitoJUnitRunner.class) public class SchemaCatalogServiceTest { @@ -25,35 +25,46 @@ public class SchemaCatalogServiceTest { private Schema catalogSchema; @Mock - private CatalogLoader catalogLoader; + private Catalog catalog; @InjectMocks private SchemaCatalogService schemaCatalogService; - @Before - public void setup() { - final Map catalog = ImmutableMap.of("uri", catalogSchema); - - when(catalogLoader.loadCatalogsFromClasspath()).thenReturn(catalog); - schemaCatalogService.initialiseCatalog(); - } - @Test - public void shouldReturnSchemaForUriId() throws Exception { - final String uri = "uri"; + public void shouldReturnSchemaForSchemaId() throws Exception { + final String schemaId = "schemaId"; - final Optional schema = schemaCatalogService.findSchema(uri); + when(catalog.getSchema(schemaId)).thenReturn(Optional.of(catalogSchema)); + + final Optional schema = schemaCatalogService.findSchema(schemaId); assertThat(schema.isPresent(), is(true)); assertThat(schema.get(), is(catalogSchema)); } @Test - public void shouldReturnOptionalEmptyIfUriIdIsUnknown() throws Exception { - final String uri = "unknown"; + public void shouldReturnOptionalEmptyIfSchemaIdIsUnknown() throws Exception { + final String schemaId = "unknown"; + + when(catalog.getSchema(schemaId)).thenReturn(Optional.empty()); - final Optional schema = schemaCatalogService.findSchema(uri); + final Optional schema = schemaCatalogService.findSchema(schemaId); assertThat(schema.isPresent(), is(false)); } -} \ No newline at end of file + + @Test + public void shouldCacheTheResultsOfTheCallToCatalog() throws Exception { + final String schemaId = "schemaId"; + + when(catalog.getSchema(schemaId)).thenReturn(Optional.of(catalogSchema)); + + assertThat(schemaCatalogService.findSchema(schemaId).get(), is(catalogSchema)); + assertThat(schemaCatalogService.findSchema(schemaId).get(), is(catalogSchema)); + assertThat(schemaCatalogService.findSchema(schemaId).get(), is(catalogSchema)); + assertThat(schemaCatalogService.findSchema(schemaId).get(), is(catalogSchema)); + assertThat(schemaCatalogService.findSchema(schemaId).get(), is(catalogSchema)); + + verify(catalog, times(1)).getSchema(schemaId); + } +} diff --git a/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaServiceIT.java b/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaServiceIT.java index c7517ed..e101436 100644 --- a/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaServiceIT.java +++ b/schema-service/src/test/java/uk/gov/justice/schema/service/SchemaServiceIT.java @@ -3,19 +3,7 @@ import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; -import uk.gov.justice.schema.catalog.CatalogLoader; -import uk.gov.justice.schema.catalog.CatalogToSchemaResolver; -import uk.gov.justice.schema.catalog.ClasspathCatalogLoader; -import uk.gov.justice.schema.catalog.FileContentsAsStringLoader; -import uk.gov.justice.schema.catalog.JsonSchemaFileLoader; -import uk.gov.justice.schema.catalog.JsonStringToSchemaConverter; -import uk.gov.justice.schema.catalog.SchemaResolver; -import uk.gov.justice.schema.catalog.SchemaResolverAndLoader; -import uk.gov.justice.schema.catalog.util.ClasspathResourceLoader; -import uk.gov.justice.schema.catalog.util.UriResolver; -import uk.gov.justice.schema.catalog.util.UrlConverter; -import uk.gov.justice.schema.client.SchemaClientFactory; -import uk.gov.justice.services.common.converter.jackson.ObjectMapperProducer; +import uk.gov.justice.schema.catalog.CatalogProducer; import java.util.Optional; @@ -38,21 +26,8 @@ public class SchemaServiceIT { @Module @Classes(cdi = true, value = { - CatalogLoader.class, - CatalogToSchemaResolver.class, - ClasspathCatalogLoader.class, - ClasspathResourceLoader.class, - FileContentsAsStringLoader.class, - JsonSchemaFileLoader.class, - JsonStringToSchemaConverter.class, - ObjectMapperProducer.class, - SchemaCatalogService.class, - SchemaClientFactory.class, - SchemaResolver.class, - SchemaResolverAndLoader.class, - UrlConverter.class, - UriResolver.class, - LoggerProducer.class + CatalogProducer.class, + SchemaCatalogService.class }) public WebApp war() { return new WebApp()