From 12f2311d084eb6c2bc6e0c023eeb9a984f3091e7 Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Wed, 11 Mar 2026 17:40:40 +0000 Subject: [PATCH] implements packer PR-03 declaration parsing and details --- .../declarations/PackerAssetDeclaration.java | 29 +++ .../PackerAssetDeclarationParseResult.java | 19 ++ .../PackerAssetDeclarationParser.java | 140 ++++++++++++++ .../PackerAssetDetailsService.java | 172 ++++++++++++++++++ .../PackerAssetDeclarationParserTest.java | 51 ++++++ .../PackerAssetDetailsServiceTest.java | 90 +++++++++ .../invalid-malformed/assets/bad/asset.json | 1 + .../assets/bad/asset.json | 11 ++ .../invalid-version/assets/bad/asset.json | 15 ++ .../assets/orphans/ui_sounds/asset.json | 15 ++ 10 files changed, 543 insertions(+) create mode 100644 prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclaration.java create mode 100644 prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParseResult.java create mode 100644 prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParser.java create mode 100644 prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDetailsService.java create mode 100644 prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDeclarationParserTest.java create mode 100644 prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDetailsServiceTest.java create mode 100644 prometeu-packer/src/test/resources/fixtures/workspaces/invalid-malformed/assets/bad/asset.json create mode 100644 prometeu-packer/src/test/resources/fixtures/workspaces/invalid-missing-fields/assets/bad/asset.json create mode 100644 prometeu-packer/src/test/resources/fixtures/workspaces/invalid-version/assets/bad/asset.json create mode 100644 prometeu-packer/src/test/resources/fixtures/workspaces/orphan-valid/assets/orphans/ui_sounds/asset.json diff --git a/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclaration.java b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclaration.java new file mode 100644 index 00000000..dd508ff7 --- /dev/null +++ b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclaration.java @@ -0,0 +1,29 @@ +package p.packer.declarations; + +import java.util.List; +import java.util.Map; +import java.util.Objects; + +public record PackerAssetDeclaration( + int schemaVersion, + String name, + String type, + Map> inputsByRole, + String outputFormat, + String outputCodec, + boolean preloadEnabled) { + + public PackerAssetDeclaration { + if (schemaVersion <= 0) { + throw new IllegalArgumentException("schemaVersion must be positive"); + } + name = Objects.requireNonNull(name, "name").trim(); + type = Objects.requireNonNull(type, "type").trim(); + inputsByRole = Map.copyOf(Objects.requireNonNull(inputsByRole, "inputsByRole")); + outputFormat = Objects.requireNonNull(outputFormat, "outputFormat").trim(); + outputCodec = Objects.requireNonNull(outputCodec, "outputCodec").trim(); + if (name.isBlank() || type.isBlank() || outputFormat.isBlank() || outputCodec.isBlank()) { + throw new IllegalArgumentException("declaration fields must not be blank"); + } + } +} diff --git a/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParseResult.java b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParseResult.java new file mode 100644 index 00000000..d6bb0a1c --- /dev/null +++ b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParseResult.java @@ -0,0 +1,19 @@ +package p.packer.declarations; + +import p.packer.api.diagnostics.PackerDiagnostic; + +import java.util.List; +import java.util.Objects; + +public record PackerAssetDeclarationParseResult( + PackerAssetDeclaration declaration, + List diagnostics) { + + public PackerAssetDeclarationParseResult { + diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics")); + } + + public boolean valid() { + return declaration != null && diagnostics.stream().noneMatch(PackerDiagnostic::blocking); + } +} diff --git a/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParser.java b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParser.java new file mode 100644 index 00000000..dd23ac5a --- /dev/null +++ b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDeclarationParser.java @@ -0,0 +1,140 @@ +package p.packer.declarations; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import p.packer.api.diagnostics.PackerDiagnostic; +import p.packer.api.diagnostics.PackerDiagnosticCategory; +import p.packer.api.diagnostics.PackerDiagnosticSeverity; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +public final class PackerAssetDeclarationParser { + private static final ObjectMapper MAPPER = new ObjectMapper(); + private static final int SUPPORTED_SCHEMA_VERSION = 1; + + public PackerAssetDeclarationParseResult parse(Path assetManifestPath) { + final Path manifestPath = Objects.requireNonNull(assetManifestPath, "assetManifestPath").toAbsolutePath().normalize(); + final List diagnostics = new ArrayList<>(); + final JsonNode root; + try { + root = MAPPER.readTree(manifestPath.toFile()); + } catch (IOException exception) { + diagnostics.add(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "Unable to parse asset.json: " + exception.getMessage(), + manifestPath, + true)); + return new PackerAssetDeclarationParseResult(null, diagnostics); + } + + final Integer schemaVersion = requiredInt(root, "schema_version", diagnostics, manifestPath); + final String name = requiredText(root, "name", diagnostics, manifestPath); + final String type = requiredText(root, "type", diagnostics, manifestPath); + final Map> inputsByRole = requiredInputs(root.path("inputs"), diagnostics, manifestPath); + final String outputFormat = requiredText(root.path("output"), "format", diagnostics, manifestPath); + final String outputCodec = requiredText(root.path("output"), "codec", diagnostics, manifestPath); + final Boolean preloadEnabled = requiredBoolean(root.path("preload"), "enabled", diagnostics, manifestPath); + + if (schemaVersion != null && schemaVersion != SUPPORTED_SCHEMA_VERSION) { + diagnostics.add(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.VERSIONING, + "Unsupported asset.json schema_version: " + schemaVersion, + manifestPath, + true)); + } + + if (diagnostics.stream().anyMatch(PackerDiagnostic::blocking)) { + return new PackerAssetDeclarationParseResult(null, diagnostics); + } + + return new PackerAssetDeclarationParseResult( + new PackerAssetDeclaration( + schemaVersion, + name, + type, + inputsByRole, + outputFormat, + outputCodec, + preloadEnabled), + diagnostics); + } + + private Integer requiredInt(JsonNode node, String fieldName, List diagnostics, Path manifestPath) { + final JsonNode field = node.path(fieldName); + if (!field.isInt()) { + diagnostics.add(missingOrInvalid(fieldName, "integer", manifestPath)); + return null; + } + return field.intValue(); + } + + private String requiredText(JsonNode node, String fieldName, List diagnostics, Path manifestPath) { + final JsonNode field = node.path(fieldName); + if (!field.isTextual() || field.asText().isBlank()) { + diagnostics.add(missingOrInvalid(fieldName, "non-blank string", manifestPath)); + return null; + } + return field.asText().trim(); + } + + private Boolean requiredBoolean(JsonNode node, String fieldName, List diagnostics, Path manifestPath) { + final JsonNode field = node.path(fieldName); + if (!field.isBoolean()) { + diagnostics.add(missingOrInvalid(fieldName, "boolean", manifestPath)); + return null; + } + return field.booleanValue(); + } + + private Map> requiredInputs(JsonNode inputsNode, List diagnostics, Path manifestPath) { + if (!inputsNode.isObject()) { + diagnostics.add(missingOrInvalid("inputs", "object of input roles", manifestPath)); + return Map.of(); + } + + final Map> result = new LinkedHashMap<>(); + inputsNode.fields().forEachRemaining(entry -> { + if (!entry.getValue().isArray()) { + diagnostics.add(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "Input role '" + entry.getKey() + "' must be an array of relative paths.", + manifestPath, + true)); + return; + } + final List values = new ArrayList<>(); + entry.getValue().forEach(value -> { + if (!value.isTextual() || value.asText().isBlank()) { + diagnostics.add(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "Input role '" + entry.getKey() + "' must contain only non-blank path strings.", + manifestPath, + true)); + return; + } + values.add(value.asText().trim()); + }); + result.put(entry.getKey(), List.copyOf(values)); + }); + return Map.copyOf(result); + } + + private PackerDiagnostic missingOrInvalid(String fieldName, String expected, Path manifestPath) { + return new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "Field '" + fieldName + "' must be a " + expected + ".", + manifestPath, + true); + } +} diff --git a/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDetailsService.java b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDetailsService.java new file mode 100644 index 00000000..eb46f26e --- /dev/null +++ b/prometeu-packer/src/main/java/p/packer/declarations/PackerAssetDetailsService.java @@ -0,0 +1,172 @@ +package p.packer.declarations; + +import p.packer.api.PackerOperationStatus; +import p.packer.api.PackerProjectContext; +import p.packer.api.assets.PackerAssetDetails; +import p.packer.api.assets.PackerAssetIdentity; +import p.packer.api.assets.PackerAssetState; +import p.packer.api.assets.PackerAssetSummary; +import p.packer.api.diagnostics.PackerDiagnostic; +import p.packer.api.diagnostics.PackerDiagnosticCategory; +import p.packer.api.diagnostics.PackerDiagnosticSeverity; +import p.packer.api.workspace.GetAssetDetailsRequest; +import p.packer.api.workspace.GetAssetDetailsResult; +import p.packer.foundation.PackerRegistryEntry; +import p.packer.foundation.PackerRegistryLookup; +import p.packer.foundation.PackerRegistryState; +import p.packer.foundation.PackerWorkspaceFoundation; +import p.packer.foundation.PackerWorkspacePaths; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +public final class PackerAssetDetailsService { + private final PackerWorkspaceFoundation workspaceFoundation; + private final PackerAssetDeclarationParser parser; + + public PackerAssetDetailsService() { + this(new PackerWorkspaceFoundation(), new PackerAssetDeclarationParser()); + } + + public PackerAssetDetailsService( + PackerWorkspaceFoundation workspaceFoundation, + PackerAssetDeclarationParser parser) { + this.workspaceFoundation = Objects.requireNonNull(workspaceFoundation, "workspaceFoundation"); + this.parser = Objects.requireNonNull(parser, "parser"); + } + + public GetAssetDetailsResult getAssetDetails(GetAssetDetailsRequest request) { + final PackerProjectContext project = Objects.requireNonNull(request, "request").project(); + final PackerRegistryState registry = workspaceFoundation.loadRegistry(project); + final ResolvedAssetReference resolved = resolveReference(project, registry, request.assetReference()); + final Path manifestPath = resolved.assetRoot().resolve("asset.json"); + final List diagnostics = new ArrayList<>(resolved.diagnostics()); + + if (!Files.isRegularFile(manifestPath)) { + diagnostics.add(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "asset.json was not found for the requested asset root.", + manifestPath, + true)); + return failureResult(resolved, diagnostics); + } + + final PackerAssetDeclarationParseResult parsed = parser.parse(manifestPath); + diagnostics.addAll(parsed.diagnostics()); + if (!parsed.valid()) { + return failureResult(resolved, diagnostics); + } + + final PackerAssetDeclaration declaration = parsed.declaration(); + final PackerAssetSummary summary = new PackerAssetSummary( + new PackerAssetIdentity( + resolved.registryEntry().map(PackerRegistryEntry::assetId).orElse(null), + resolved.registryEntry().map(PackerRegistryEntry::assetUuid).orElse(null), + declaration.name(), + resolved.assetRoot()), + resolved.registryEntry().isPresent() ? PackerAssetState.MANAGED : PackerAssetState.ORPHAN, + declaration.type(), + declaration.preloadEnabled(), + !diagnostics.isEmpty()); + final PackerAssetDetails details = new PackerAssetDetails( + summary, + declaration.outputFormat(), + declaration.outputCodec(), + resolveInputs(resolved.assetRoot(), declaration.inputsByRole()), + diagnostics); + return new GetAssetDetailsResult( + diagnostics.isEmpty() ? PackerOperationStatus.SUCCESS : PackerOperationStatus.PARTIAL, + "Asset details resolved from packer declaration state.", + details, + diagnostics); + } + + private GetAssetDetailsResult failureResult(ResolvedAssetReference resolved, List diagnostics) { + final PackerAssetSummary summary = new PackerAssetSummary( + new PackerAssetIdentity( + resolved.registryEntry().map(PackerRegistryEntry::assetId).orElse(null), + resolved.registryEntry().map(PackerRegistryEntry::assetUuid).orElse(null), + resolved.assetRoot().getFileName().toString(), + resolved.assetRoot()), + PackerAssetState.INVALID, + "unknown", + false, + true); + final PackerAssetDetails details = new PackerAssetDetails(summary, "unknown", "unknown", Map.of(), diagnostics); + return new GetAssetDetailsResult( + PackerOperationStatus.FAILED, + "Asset declaration is invalid or unreadable.", + details, + diagnostics); + } + + private Map> resolveInputs(Path assetRoot, Map> inputsByRole) { + final Map> resolved = new LinkedHashMap<>(); + inputsByRole.forEach((role, inputs) -> resolved.put( + role, + inputs.stream().map(input -> assetRoot.resolve(input).toAbsolutePath().normalize()).toList())); + return Map.copyOf(resolved); + } + + private ResolvedAssetReference resolveReference(PackerProjectContext project, PackerRegistryState registry, String reference) { + final PackerRegistryLookup lookup = workspaceFoundation.lookup(); + final Optional byId = parseAssetId(reference).flatMap(assetId -> lookup.findByAssetId(registry, assetId)); + if (byId.isPresent()) { + return new ResolvedAssetReference( + PackerWorkspacePaths.assetRoot(project, byId.get().root()), + byId, + List.of()); + } + + final Optional byUuid = lookup.findByAssetUuid(registry, reference); + if (byUuid.isPresent()) { + return new ResolvedAssetReference( + PackerWorkspacePaths.assetRoot(project, byUuid.get().root()), + byUuid, + List.of()); + } + + final Path candidateRoot = PackerWorkspacePaths.assetRoot(project, reference); + if (Files.isDirectory(candidateRoot) || Files.isRegularFile(candidateRoot.resolve("asset.json"))) { + return new ResolvedAssetReference(candidateRoot, lookup.findByRoot(project, registry, candidateRoot), List.of()); + } + + final Path missingRoot = candidateRoot; + return new ResolvedAssetReference( + missingRoot, + Optional.empty(), + List.of(new PackerDiagnostic( + PackerDiagnosticSeverity.ERROR, + PackerDiagnosticCategory.STRUCTURAL, + "Requested asset reference could not be resolved.", + missingRoot, + true))); + } + + private Optional parseAssetId(String reference) { + try { + return Optional.of(Integer.parseInt(reference.trim())); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } + + private record ResolvedAssetReference( + Path assetRoot, + Optional registryEntry, + List diagnostics) { + + private ResolvedAssetReference { + assetRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize(); + registryEntry = Objects.requireNonNull(registryEntry, "registryEntry"); + diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics")); + } + } +} diff --git a/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDeclarationParserTest.java b/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDeclarationParserTest.java new file mode 100644 index 00000000..799cfb43 --- /dev/null +++ b/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDeclarationParserTest.java @@ -0,0 +1,51 @@ +package p.packer.declarations; + +import org.junit.jupiter.api.Test; +import p.packer.api.diagnostics.PackerDiagnosticCategory; +import p.packer.testing.PackerFixtureLocator; + +import static org.junit.jupiter.api.Assertions.*; + +final class PackerAssetDeclarationParserTest { + private final PackerAssetDeclarationParser parser = new PackerAssetDeclarationParser(); + + @Test + void parsesValidDeclarationFixture() { + final var result = parser.parse(PackerFixtureLocator.fixtureRoot("workspaces/managed-basic/assets/ui/atlas/asset.json")); + + assertTrue(result.valid()); + assertNotNull(result.declaration()); + assertEquals(1, result.declaration().schemaVersion()); + assertEquals("ui_atlas", result.declaration().name()); + assertEquals("image_bank", result.declaration().type()); + assertEquals("TILES/indexed_v1", result.declaration().outputFormat()); + assertEquals("RAW", result.declaration().outputCodec()); + assertTrue(result.declaration().preloadEnabled()); + } + + @Test + void rejectsMalformedJsonWithStructuralDiagnostic() { + final var result = parser.parse(PackerFixtureLocator.fixtureRoot("workspaces/invalid-malformed/assets/bad/asset.json")); + + assertFalse(result.valid()); + assertNull(result.declaration()); + assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.category() == PackerDiagnosticCategory.STRUCTURAL)); + } + + @Test + void rejectsMissingRequiredFields() { + final var result = parser.parse(PackerFixtureLocator.fixtureRoot("workspaces/invalid-missing-fields/assets/bad/asset.json")); + + assertFalse(result.valid()); + assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("name"))); + assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("format"))); + } + + @Test + void rejectsUnsupportedSchemaVersion() { + final var result = parser.parse(PackerFixtureLocator.fixtureRoot("workspaces/invalid-version/assets/bad/asset.json")); + + assertFalse(result.valid()); + assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.category() == PackerDiagnosticCategory.VERSIONING)); + } +} diff --git a/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDetailsServiceTest.java b/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDetailsServiceTest.java new file mode 100644 index 00000000..00a724a4 --- /dev/null +++ b/prometeu-packer/src/test/java/p/packer/declarations/PackerAssetDetailsServiceTest.java @@ -0,0 +1,90 @@ +package p.packer.declarations; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import p.packer.api.PackerOperationStatus; +import p.packer.api.PackerProjectContext; +import p.packer.api.assets.PackerAssetState; +import p.packer.api.workspace.GetAssetDetailsRequest; +import p.packer.testing.PackerFixtureLocator; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Comparator; + +import static org.junit.jupiter.api.Assertions.*; + +final class PackerAssetDetailsServiceTest { + @TempDir + Path tempDir; + + @Test + void returnsManagedDetailsForRegisteredAssetReferenceById() throws Exception { + final Path projectRoot = copyFixture("workspaces/managed-basic", tempDir.resolve("managed")); + final PackerAssetDetailsService service = new PackerAssetDetailsService(); + + final var result = service.getAssetDetails(new GetAssetDetailsRequest(project(projectRoot), "1")); + + assertEquals(PackerOperationStatus.SUCCESS, result.status()); + assertEquals(PackerAssetState.MANAGED, result.details().summary().state()); + assertEquals("ui_atlas", result.details().summary().identity().assetName()); + assertEquals("TILES/indexed_v1", result.details().outputFormat()); + assertTrue(result.diagnostics().isEmpty()); + } + + @Test + void returnsOrphanDetailsForValidUnregisteredRootReference() throws Exception { + final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("orphan")); + final PackerAssetDetailsService service = new PackerAssetDetailsService(); + + final var result = service.getAssetDetails(new GetAssetDetailsRequest(project(projectRoot), "orphans/ui_sounds")); + + assertEquals(PackerOperationStatus.SUCCESS, result.status()); + assertEquals(PackerAssetState.ORPHAN, result.details().summary().state()); + assertEquals("ui_sounds", result.details().summary().identity().assetName()); + } + + @Test + void returnsInvalidDetailsForInvalidDeclaration() throws Exception { + final Path projectRoot = copyFixture("workspaces/invalid-missing-fields", tempDir.resolve("invalid")); + final PackerAssetDetailsService service = new PackerAssetDetailsService(); + + final var result = service.getAssetDetails(new GetAssetDetailsRequest(project(projectRoot), "bad")); + + assertEquals(PackerOperationStatus.FAILED, result.status()); + assertEquals(PackerAssetState.INVALID, result.details().summary().state()); + assertFalse(result.diagnostics().isEmpty()); + } + + @Test + void returnsFailureWhenReferenceCannotBeResolved() { + final PackerAssetDetailsService service = new PackerAssetDetailsService(); + + final var result = service.getAssetDetails(new GetAssetDetailsRequest(project(tempDir.resolve("empty")), "missing/root")); + + assertEquals(PackerOperationStatus.FAILED, result.status()); + assertEquals(PackerAssetState.INVALID, result.details().summary().state()); + assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("could not be resolved"))); + } + + private PackerProjectContext project(Path root) { + return new PackerProjectContext("main", root); + } + + private Path copyFixture(String relativePath, Path targetRoot) throws Exception { + final Path sourceRoot = PackerFixtureLocator.fixtureRoot(relativePath); + try (var stream = Files.walk(sourceRoot)) { + for (Path source : stream.sorted(Comparator.naturalOrder()).toList()) { + final Path target = targetRoot.resolve(sourceRoot.relativize(source).toString()); + if (Files.isDirectory(source)) { + Files.createDirectories(target); + } else { + Files.createDirectories(target.getParent()); + Files.copy(source, target); + } + } + } + return targetRoot; + } +} diff --git a/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-malformed/assets/bad/asset.json b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-malformed/assets/bad/asset.json new file mode 100644 index 00000000..9945e39a --- /dev/null +++ b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-malformed/assets/bad/asset.json @@ -0,0 +1 @@ +{ nope diff --git a/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-missing-fields/assets/bad/asset.json b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-missing-fields/assets/bad/asset.json new file mode 100644 index 00000000..fb786941 --- /dev/null +++ b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-missing-fields/assets/bad/asset.json @@ -0,0 +1,11 @@ +{ + "schema_version": 1, + "type": "image_bank", + "inputs": "wrong", + "output": { + "codec": "" + }, + "preload": { + "enabled": true + } +} diff --git a/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-version/assets/bad/asset.json b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-version/assets/bad/asset.json new file mode 100644 index 00000000..11465af8 --- /dev/null +++ b/prometeu-packer/src/test/resources/fixtures/workspaces/invalid-version/assets/bad/asset.json @@ -0,0 +1,15 @@ +{ + "schema_version": 9, + "name": "future_asset", + "type": "image_bank", + "inputs": { + "sprites": ["future.png"] + }, + "output": { + "format": "TILES/indexed_v1", + "codec": "RAW" + }, + "preload": { + "enabled": true + } +} diff --git a/prometeu-packer/src/test/resources/fixtures/workspaces/orphan-valid/assets/orphans/ui_sounds/asset.json b/prometeu-packer/src/test/resources/fixtures/workspaces/orphan-valid/assets/orphans/ui_sounds/asset.json new file mode 100644 index 00000000..2f0f5aa3 --- /dev/null +++ b/prometeu-packer/src/test/resources/fixtures/workspaces/orphan-valid/assets/orphans/ui_sounds/asset.json @@ -0,0 +1,15 @@ +{ + "schema_version": 1, + "name": "ui_sounds", + "type": "sound_bank", + "inputs": { + "sources": ["confirm.wav"] + }, + "output": { + "format": "SOUND/bank_v1", + "codec": "RAW" + }, + "preload": { + "enabled": false + } +}