Light, fluffy, and always free - The AWS Local Emulator alternative
feat(glue): add crawler classifier APIs (#3985)
XuJiand34876334503
diff --git a/docs/services/glue.md b/docs/services/glue.mdindex 12618b6929..f323578538 100644--- a/docs/services/glue.md+++ b/docs/services/glue.md@@ -84,6 +84,16 @@ only arises from a backfill failure.| UpdateCrawler | Updates a crawler. || DeleteCrawler | Removes a specified crawler from the AWS Glue Data Catalog. |+#### Classifiers++| Action | Description |+|--------|-------------|+| CreateClassifier | Creates a Grok, XML, JSON, or CSV classifier. |+| GetClassifier | Retrieves a classifier by name. |+| GetClassifiers | Lists classifiers, paged by `MaxResults` and `NextToken`. |+| UpdateClassifier | Partially updates a classifier without changing its type. |+| DeleteClassifier | Deletes a classifier by name. |+### Schema Registry#### Registriesdiff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.javaindex 4694a53a49..e0216f8317 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java@@ -235,6 +235,27 @@ public class GlueJsonHandler {glueService.deleteJob(req.getJobName(), region);yield Response.ok(new DeleteJobResponse(req.getJobName())).build();}+ case "CreateClassifier" -> {+ Classifier classifier = mapper.treeToValue(request, Classifier.class);+ glueService.createClassifier(classifier);+ yield Response.ok().build();+ }+ case "GetClassifier" -> Response.ok(Map.of(+ "Classifier", glueService.getClassifier(request.path("Name").asText(null)))).build();+ case "GetClassifiers" -> {+ GlueService.Page<Classifier> page = glueService.getClassifiers(+ readMaxResults(request), readNextToken(request));+ yield Response.ok(pageResponse("Classifiers", page.items(), page.nextToken())).build();+ }+ case "UpdateClassifier" -> {+ Classifier classifier = mapper.treeToValue(request, Classifier.class);+ glueService.updateClassifier(classifier);+ yield Response.ok().build();+ }+ case "DeleteClassifier" -> {+ glueService.deleteClassifier(request.path("Name").asText(null));+ yield Response.ok().build();+ }case "CreateCrawler" -> {CreateCrawlerRequest req = mapper.treeToValue(request, CreateCrawlerRequest.class);Crawler crawler = toDomain(req);diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.javaindex 36c2781a8f..619cb1d9d4 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.glue.model.Classifier;import io.github.hectorvent.floci.services.glue.model.Column;import io.github.hectorvent.floci.services.glue.model.Crawler;import io.github.hectorvent.floci.services.glue.model.CrawlerTargets;@@ -41,6 +42,7 @@ import java.util.List;import java.util.Locale;import java.util.Map;import java.util.Optional;+import java.util.Set;import java.util.regex.Matcher;import java.util.regex.Pattern;import java.util.regex.PatternSyntaxException;@@ -51,6 +53,11 @@ public class GlueService {private static final Logger LOG = Logger.getLogger(GlueService.class);private static final int MAX_FUNCTION_PATTERN_LENGTH = 255;private static final int MAX_FUNCTION_RESULTS = 100;+ private static final Set<String> CSV_HEADER_VALUES = Set.of("UNKNOWN", "PRESENT", "ABSENT");+ private static final Set<String> CSV_SERDE_VALUES = Set.of("OpenCSVSerDe", "LazySimpleSerDe", "None");+ private static final Set<String> CSV_CUSTOM_DATATYPES = Set.of(+ "BINARY", "BOOLEAN", "DATE", "DECIMAL", "DOUBLE", "FLOAT",+ "INT", "LONG", "SHORT", "STRING", "TIMESTAMP");static final String COLUMN_NAME = "ColumnName";static final String COLUMN_TYPE = "ColumnType";static final String ANALYZED_TIME = "AnalyzedTime";@@ -81,6 +88,7 @@ public class GlueService {private final StorageBackend<String, UserDefinedFunction> functionStore;private final StorageBackend<String, Job> jobStore;private final StorageBackend<String, Crawler> crawlerStore;+ private final StorageBackend<String, Classifier> classifierStore;private final GlueSchemaRegistryService schemaRegistryService;private final RegionResolver regionResolver;private final ResourceGroupsTaggingService resourceGroupsTaggingService;@@ -102,6 +110,7 @@ public class GlueService {this.functionStore = storageFactory.create("glue", "functions.json", new TypeReference<>() {});this.jobStore = storageFactory.create("glue", "jobs.json", new TypeReference<>() {});this.crawlerStore = storageFactory.create("glue", "crawlers.json", new TypeReference<>() {});+ this.classifierStore = storageFactory.create("glue", "classifiers.json", new TypeReference<>() {});this.schemaRegistryService = schemaRegistryService;this.regionResolver = regionResolver;this.resourceGroupsTaggingService = resourceGroupsTaggingService;@@ -117,6 +126,7 @@ public class GlueService {StorageBackend<String, UserDefinedFunction> functionStore,StorageBackend<String, Job> jobStore,StorageBackend<String, Crawler> crawlerStore,+ StorageBackend<String, Classifier> classifierStore,GlueSchemaRegistryService schemaRegistryService,RegionResolver regionResolver,ResourceGroupsTaggingService resourceGroupsTaggingService) {@@ -130,6 +140,7 @@ public class GlueService {this.functionStore = functionStore;this.jobStore = jobStore;this.crawlerStore = crawlerStore;+ this.classifierStore = classifierStore;this.schemaRegistryService = schemaRegistryService;this.regionResolver = regionResolver;this.resourceGroupsTaggingService = resourceGroupsTaggingService;@@ -1621,6 +1632,166 @@ public class GlueService {LOG.infov("Deleted Glue Job: {0}", name);}+ public void createClassifier(Classifier classifier) {+ validateClassifierShape(classifier);+ String name = classifier.name();+ validateClassifierName(name);+ if (classifierStore.get(name).isPresent()) {+ throw new AwsException("AlreadyExistsException", "Classifier " + name + " already exists.", 400);+ }++ Map<String, Object> details = new LinkedHashMap<>(classifier.selectedDetails());+ validateClassifierDetails(classifier.selectedKind(), details);+ double now = Instant.now().toEpochMilli() / 1000.0d;+ details.put("CreationTime", now);+ details.put("LastUpdated", now);+ details.put("Version", 1L);+ classifierStore.put(name, classifier.copyWithDetails(details));+ LOG.infov("Created Glue Classifier: {0}", name);+ }++ public Classifier getClassifier(String name) {+ validateClassifierName(name);+ return classifierStore.get(name)+ .orElseThrow(() -> new AwsException(+ "EntityNotFoundException", "Classifier " + name + " not found.", 400));+ }++ public Page<Classifier> getClassifiers(Integer maxResults, String nextToken) {+ List<Classifier> classifiers = classifierStore.scan(key -> true);+ classifiers.sort(Comparator.comparing(Classifier::name));+ return paginate(classifiers, maxResults, nextToken);+ }++ public void updateClassifier(Classifier update) {+ validateClassifierShape(update);+ String name = update.name();+ validateClassifierName(name);+ Classifier existing = getClassifier(name);+ if (!existing.selectedKind().equals(update.selectedKind())) {+ throw new AwsException("InvalidInputException", "Classifier type cannot be changed.", 400);+ }++ Map<String, Object> details = new LinkedHashMap<>(existing.selectedDetails());+ update.selectedDetails().forEach((key, value) -> {+ if (!"CreationTime".equals(key) && !"LastUpdated".equals(key) && !"Version".equals(key)) {+ details.put(key, value);+ }+ });+ validateClassifierDetails(existing.selectedKind(), details);+ Number version = (Number) existing.selectedDetails().get("Version");+ details.put("CreationTime", existing.selectedDetails().get("CreationTime"));+ details.put("LastUpdated", Instant.now().toEpochMilli() / 1000.0d);+ details.put("Version", (version == null ? 1L : version.longValue()) + 1L);+ classifierStore.put(name, existing.copyWithDetails(details));+ LOG.infov("Updated Glue Classifier: {0}", name);+ }++ public void deleteClassifier(String name) {+ validateClassifierName(name);+ if (classifierStore.get(name).isEmpty()) {+ throw new AwsException("EntityNotFoundException", "Classifier " + name + " not found.", 400);+ }+ classifierStore.delete(name);+ LOG.infov("Deleted Glue Classifier: {0}", name);+ }++ private void validateClassifierShape(Classifier classifier) {+ if (classifier == null || classifier.selectedKindCount() != 1) {+ throw new AwsException(+ "InvalidInputException", "Exactly one classifier type must be specified.", 400);+ }+ }++ private void validateClassifierName(String name) {+ validateRequired(name, "Name");+ if (name.length() > 255 || name.indexOf('\r') >= 0 || name.indexOf('\n') >= 0) {+ throw new AwsException("InvalidInputException", "Name must be between 1 and 255 characters.", 400);+ }+ }++ private void validateClassifierDetails(String kind, Map<String, Object> details) {+ validateClassifierName(stringValue(details, "Name", true));+ switch (kind) {+ case "GrokClassifier" -> validateGrokClassifier(details);+ case "XMLClassifier" -> stringValue(details, "Classification", true);+ case "JsonClassifier" -> stringValue(details, "JsonPath", true);+ case "CsvClassifier" -> validateCsvClassifier(details);+ default -> throw new AwsException("InvalidInputException", "Unsupported classifier type.", 400);+ }+ }++ private void validateGrokClassifier(Map<String, Object> details) {+ stringValue(details, "Classification", true);+ String grokPattern = stringValue(details, "GrokPattern", true);+ if (grokPattern.length() > 2048) {+ throw new AwsException("InvalidInputException", "GrokPattern must not exceed 2048 characters.", 400);+ }+ String customPatterns = stringValue(details, "CustomPatterns", false);+ if (customPatterns != null && customPatterns.length() > 16000) {+ throw new AwsException("InvalidInputException", "CustomPatterns must not exceed 16000 characters.", 400);+ }+ }++ private void validateCsvClassifier(Map<String, Object> details) {+ String delimiter = validateSingleCharacter(details, "Delimiter");+ String quoteSymbol = validateSingleCharacter(details, "QuoteSymbol");+ if (delimiter != null && delimiter.equals(quoteSymbol)) {+ throw new AwsException(+ "InvalidInputException", "QuoteSymbol must be different from Delimiter.", 400);+ }+ validateEnum(details, "ContainsHeader", CSV_HEADER_VALUES);+ validateEnum(details, "Serde", CSV_SERDE_VALUES);+ validateStringList(details, "Header", null);+ validateStringList(details, "CustomDatatypes", CSV_CUSTOM_DATATYPES);+ }++ private String validateSingleCharacter(Map<String, Object> details, String field) {+ String value = stringValue(details, field, false);+ if (value != null && (value.codePointCount(0, value.length()) != 1+ || value.indexOf('\r') >= 0 || value.indexOf('\n') >= 0)) {+ throw new AwsException("InvalidInputException", field + " must be exactly one character.", 400);+ }+ return value;+ }++ private void validateEnum(Map<String, Object> details, String field, Set<String> allowed) {+ String value = stringValue(details, field, false);+ if (value != null && !allowed.contains(value)) {+ throw new AwsException("InvalidInputException", "Invalid " + field + ": " + value, 400);+ }+ }++ private void validateStringList(Map<String, Object> details, String field, Set<String> allowed) {+ Object value = details.get(field);+ if (value == null) {+ return;+ }+ if (!(value instanceof List<?> values)) {+ throw new AwsException("InvalidInputException", field + " must be a list.", 400);+ }+ for (Object item : values) {+ if (!(item instanceof String text) || text.isEmpty() || text.length() > 255+ || (allowed != null && !allowed.contains(text))) {+ throw new AwsException("InvalidInputException", "Invalid value in " + field + ".", 400);+ }+ }+ }++ private String stringValue(Map<String, Object> details, String field, boolean required) {+ Object value = details.get(field);+ if (value == null) {+ if (required) {+ throw new AwsException("InvalidInputException", field + " is required.", 400);+ }+ return null;+ }+ if (!(value instanceof String text) || (required && text.isBlank())) {+ throw new AwsException("InvalidInputException", field + " must be a string.", 400);+ }+ return text;+ }+public void createCrawler(Crawler crawler) {createCrawler(crawler, null, regionResolver.getDefaultRegion());}diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/model/Classifier.java b/src/main/java/io/github/hectorvent/floci/services/glue/model/Classifier.javanew file mode 100644index 0000000000..24bf6fb9f8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/glue/model/Classifier.java@@ -0,0 +1,94 @@+package io.github.hectorvent.floci.services.glue.model;++import com.fasterxml.jackson.annotation.JsonInclude;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+@JsonInclude(JsonInclude.Include.NON_NULL)+public class Classifier {+ @JsonProperty("GrokClassifier")+ private Map<String, Object> grokClassifier;++ @JsonProperty("XMLClassifier")+ private Map<String, Object> xmlClassifier;++ @JsonProperty("JsonClassifier")+ private Map<String, Object> jsonClassifier;++ @JsonProperty("CsvClassifier")+ private Map<String, Object> csvClassifier;++ public Classifier() {}++ public Map<String, Object> getGrokClassifier() { return grokClassifier; }+ public void setGrokClassifier(Map<String, Object> grokClassifier) { this.grokClassifier = grokClassifier; }++ public Map<String, Object> getXmlClassifier() { return xmlClassifier; }+ public void setXmlClassifier(Map<String, Object> xmlClassifier) { this.xmlClassifier = xmlClassifier; }++ public Map<String, Object> getJsonClassifier() { return jsonClassifier; }+ public void setJsonClassifier(Map<String, Object> jsonClassifier) { this.jsonClassifier = jsonClassifier; }++ public Map<String, Object> getCsvClassifier() { return csvClassifier; }+ public void setCsvClassifier(Map<String, Object> csvClassifier) { this.csvClassifier = csvClassifier; }++ public String selectedKind() {+ if (grokClassifier != null) {+ return "GrokClassifier";+ }+ if (xmlClassifier != null) {+ return "XMLClassifier";+ }+ if (jsonClassifier != null) {+ return "JsonClassifier";+ }+ if (csvClassifier != null) {+ return "CsvClassifier";+ }+ return null;+ }++ public int selectedKindCount() {+ int count = 0;+ count += grokClassifier == null ? 0 : 1;+ count += xmlClassifier == null ? 0 : 1;+ count += jsonClassifier == null ? 0 : 1;+ count += csvClassifier == null ? 0 : 1;+ return count;+ }++ public Map<String, Object> selectedDetails() {+ return switch (selectedKind()) {+ case "GrokClassifier" -> grokClassifier;+ case "XMLClassifier" -> xmlClassifier;+ case "JsonClassifier" -> jsonClassifier;+ case "CsvClassifier" -> csvClassifier;+ case null -> null;+ default -> throw new IllegalStateException("Unknown classifier kind");+ };+ }++ public String name() {+ Map<String, Object> details = selectedDetails();+ Object name = details == null ? null : details.get("Name");+ return name instanceof String value ? value : null;+ }++ public Classifier copyWithDetails(Map<String, Object> details) {+ Classifier copy = new Classifier();+ Map<String, Object> copiedDetails = new LinkedHashMap<>(details);+ switch (selectedKind()) {+ case "GrokClassifier" -> copy.setGrokClassifier(copiedDetails);+ case "XMLClassifier" -> copy.setXmlClassifier(copiedDetails);+ case "JsonClassifier" -> copy.setJsonClassifier(copiedDetails);+ case "CsvClassifier" -> copy.setCsvClassifier(copiedDetails);+ case null -> throw new IllegalStateException("Classifier kind is required");+ default -> throw new IllegalStateException("Unknown classifier kind");+ }+ return copy;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.javaindex b7f23ddc12..9c44ec9e7f 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java@@ -380,6 +380,133 @@ class GlueJsonHandlerTest {assertEquals("cron(0 0 * * ? *)", crawler.get("Schedule").get("ScheduleExpression").asText());}+ @Test+ void classifierCrudPreservesPartialUpdatesAndMetadata() throws Exception {+ ObjectNode create = mapper.createObjectNode();+ create.putObject("GrokClassifier")+ .put("Name", "access-logs")+ .put("Classification", "apache")+ .put("GrokPattern", "%{COMMONAPACHELOG}")+ .put("CustomPatterns", "ORIGINAL value");+ assertEquals(200, handler.handle("CreateClassifier", create, REGION).getStatus());++ JsonNode created = mapper.valueToTree(body(handler.handle(+ "GetClassifier", mapper.createObjectNode().put("Name", "access-logs"), REGION)))+ .get("Classifier").get("GrokClassifier");+ assertEquals(1, created.get("Version").asLong());+ assertTrue(created.has("CreationTime"));+ assertTrue(created.has("LastUpdated"));++ ObjectNode update = mapper.createObjectNode();+ update.putObject("GrokClassifier")+ .put("Name", "access-logs")+ .put("Classification", "apache-updated");+ assertEquals(200, handler.handle("UpdateClassifier", update, REGION).getStatus());++ JsonNode updated = mapper.valueToTree(body(handler.handle(+ "GetClassifier", mapper.createObjectNode().put("Name", "access-logs"), REGION)))+ .get("Classifier").get("GrokClassifier");+ assertEquals("apache-updated", updated.get("Classification").asText());+ assertEquals("%{COMMONAPACHELOG}", updated.get("GrokPattern").asText());+ assertEquals("ORIGINAL value", updated.get("CustomPatterns").asText());+ assertEquals(created.get("CreationTime"), updated.get("CreationTime"));+ assertEquals(2, updated.get("Version").asLong());++ assertEquals(200, handler.handle(+ "DeleteClassifier", mapper.createObjectNode().put("Name", "access-logs"), REGION).getStatus());+ AwsException missing = assertThrows(AwsException.class, () -> handler.handle(+ "GetClassifier", mapper.createObjectNode().put("Name", "access-logs"), REGION));+ assertEquals("EntityNotFoundException", missing.getErrorCode());+ }++ @Test+ void allClassifierKindsRoundTripAndListsArePaginatedByName() throws Exception {+ ObjectNode grok = mapper.createObjectNode();+ grok.putObject("GrokClassifier")+ .put("Name", "d-grok")+ .put("Classification", "logs")+ .put("GrokPattern", "%{GREEDYDATA:message}");+ ObjectNode json = mapper.createObjectNode();+ json.putObject("JsonClassifier").put("Name", "b-json").put("JsonPath", "$.records[*]");+ ObjectNode xml = mapper.createObjectNode();+ xml.putObject("XMLClassifier")+ .put("Name", "a-xml")+ .put("Classification", "xml")+ .put("RowTag", "record");+ ObjectNode csv = mapper.createObjectNode();+ csv.putObject("CsvClassifier")+ .put("Name", "c-csv")+ .put("Delimiter", ",")+ .put("QuoteSymbol", "\"")+ .put("ContainsHeader", "PRESENT")+ .put("Serde", "OpenCSVSerDe")+ .putArray("CustomDatatypes").add("STRING").add("TIMESTAMP");+ assertEquals(200, handler.handle("CreateClassifier", grok, REGION).getStatus());+ assertEquals(200, handler.handle("CreateClassifier", json, REGION).getStatus());+ assertEquals(200, handler.handle("CreateClassifier", xml, REGION).getStatus());+ assertEquals(200, handler.handle("CreateClassifier", csv, REGION).getStatus());++ ObjectNode firstRequest = mapper.createObjectNode().put("MaxResults", 2);+ JsonNode first = mapper.valueToTree(body(handler.handle("GetClassifiers", firstRequest, REGION)));+ assertEquals(2, first.get("Classifiers").size());+ assertEquals("a-xml", first.get("Classifiers").get(0).get("XMLClassifier").get("Name").asText());+ assertEquals("b-json", first.get("Classifiers").get(1).get("JsonClassifier").get("Name").asText());+ assertEquals("2", first.get("NextToken").asText());++ ObjectNode secondRequest = mapper.createObjectNode().put("MaxResults", 2).put("NextToken", "2");+ JsonNode second = mapper.valueToTree(body(handler.handle("GetClassifiers", secondRequest, REGION)));+ assertEquals(2, second.get("Classifiers").size());+ assertEquals("c-csv", second.get("Classifiers").get(0).get("CsvClassifier").get("Name").asText());+ assertEquals("d-grok", second.get("Classifiers").get(1).get("GrokClassifier").get("Name").asText());+ assertTrue(!second.has("NextToken"));+ }++ @Test+ void classifierValidationRejectsAmbiguousAndInvalidRequests() throws Exception {+ ObjectNode ambiguous = mapper.createObjectNode();+ ambiguous.putObject("JsonClassifier").put("Name", "ambiguous").put("JsonPath", "$");+ ambiguous.putObject("XMLClassifier").put("Name", "ambiguous").put("Classification", "xml");+ assertClassifierError("InvalidInputException", "CreateClassifier", ambiguous);++ ObjectNode invalidCsv = mapper.createObjectNode();+ invalidCsv.putObject("CsvClassifier")+ .put("Name", "invalid-csv")+ .put("Delimiter", ",")+ .put("QuoteSymbol", ",")+ .put("ContainsHeader", "MAYBE");+ assertClassifierError("InvalidInputException", "CreateClassifier", invalidCsv);++ ObjectNode invalidGrok = mapper.createObjectNode();+ invalidGrok.putObject("GrokClassifier")+ .put("Name", "invalid-grok")+ .put("Classification", "logs");+ assertClassifierError("InvalidInputException", "CreateClassifier", invalidGrok);+ }++ @Test+ void classifierCreateUpdateAndDeleteUseAwsErrors() throws Exception {+ ObjectNode create = mapper.createObjectNode();+ create.putObject("JsonClassifier").put("Name", "events").put("JsonPath", "$.events[*]");+ assertEquals(200, handler.handle("CreateClassifier", create, REGION).getStatus());+ assertClassifierError("AlreadyExistsException", "CreateClassifier", create);++ ObjectNode wrongKind = mapper.createObjectNode();+ wrongKind.putObject("XMLClassifier").put("Name", "events").put("Classification", "xml");+ assertClassifierError("InvalidInputException", "UpdateClassifier", wrongKind);++ ObjectNode missing = mapper.createObjectNode();+ missing.putObject("JsonClassifier").put("Name", "missing").put("JsonPath", "$");+ assertClassifierError("EntityNotFoundException", "UpdateClassifier", missing);+ assertClassifierError("EntityNotFoundException", "DeleteClassifier",+ mapper.createObjectNode().put("Name", "missing"));+ }++ private void assertClassifierError(String errorCode, String action, JsonNode request) {+ AwsException exception = assertThrows(AwsException.class,+ () -> handler.handle(action, request, REGION));+ assertEquals(errorCode, exception.getErrorCode());+ }+@Testvoid createJobSucceeds() throws Exception {ObjectNode request = mapper.createObjectNode();diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.javaindex 80bda3da9f..0f67444e87 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java@@ -7,6 +7,7 @@ import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.glue.model.Classifier;import io.github.hectorvent.floci.services.glue.model.Column;import io.github.hectorvent.floci.services.glue.model.Database;import io.github.hectorvent.floci.services.glue.model.Crawler;@@ -86,6 +87,7 @@ class GlueServiceTest {new InMemoryStorage<String, UserDefinedFunction>(),new InMemoryStorage<String, Job>(),new InMemoryStorage<String, Crawler>(),+ new InMemoryStorage<String, Classifier>(),schemaRegistryService, regionResolver, new ResourceGroupsTaggingService(null));glueService.createDatabase(new Database("db1"));}