Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codeartifact): add DeletePackage for all package formats (#5320)
Priamo Germosenceab47e78593
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdindex a0f0bebf72..80d0e05cf6 100644--- a/docs/services/codeartifact.md+++ b/docs/services/codeartifact.md@@ -39,6 +39,7 @@ the remaining formats (NuGet, etc.) have no real proxy behind them yet.| `DisassociateExternalConnection` | Removes a repository's external connection. || `PublishPackageVersion` | Uploads a generic-format asset, creating or extending a package version; requires `x-amz-content-sha256` and verifies it against the real hash of the bytes received. || `DescribePackage` | Returns a package's format, namespace, name, and origin controls (`publish` and `upstream` restrictions). |+| `DeletePackage` | Deletes a package and every one of its versions; `ResourceNotFoundException` for one that does not exist. || `DescribePackageVersion` | Returns a package version's status, revision, and origin. || `GetPackageVersionAsset` | Downloads one asset from a package version by name, optionally pinned to a specific revision. || `TagResource` | Adds or updates tags on a domain or repository ARN. |diff --git a/docs/services/index.md b/docs/services/index.mdindex ee17d17718..8a409d704b 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -121,7 +121,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [AWS Backup](backup.md) | `/backup-vaults/*`, `/backup/plans/*`, `/backup-jobs/*`, `/supported-resource-types` | REST JSON | 20 || [AWS FIS](fis.md) | `/experimentTemplates/*`, `/experiments/*`, `/actions/*`, `/targetResourceTypes/*`, `/safetyLevers/*`, `/tags/*` | REST JSON | 26 || [CodeGuru Reviewer](codegurureviewer.md) | `/associations`, `/associations/{associationArn}`, `/tags/*` | REST JSON | 7 |-| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 27 |+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 28 || [CloudFront](cloudfront.md) | `/2020-05-31/distribution/*`, `/2020-05-31/cache-policy/*`, `/2020-05-31/function/*` | REST XML | 50 || [Route53](route53.md) | `/2013-04-01/hostedzone/*`, `/2013-04-01/healthcheck/*`, `/2013-04-01/change/*` | REST XML | 27 || [Route 53 Resolver](route53resolver.md) | `POST /` + `X-Amz-Target: Route53Resolver.*` | JSON 1.1 | 18 |diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.javaindex 116bc34c45..9ea8b5d5c5 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java@@ -342,6 +342,20 @@ public class CodeArtifactController {return ok(single("package", packageDescription(described)));}+ @DELETE+ @Path("/v1/package")+ public Response deletePackage(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("format") String format,+ @QueryParam("namespace") String namespace,+ @QueryParam("package") String packageName) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactService.PackageDescription deleted = service.deletePackage(region, domain, domainOwner,+ repository, format, namespace, packageName);+ return ok(single("deletedPackage", deletedPackageDescription(deleted)));+ }+@GET@Path("/v1/package/version")public Response describePackageVersion(@Context HttpHeaders headers, @QueryParam("domain") String domain,@@ -511,6 +525,25 @@ public class CodeArtifactController {return node;}+ /**+ * {@code PackageSummary}, real AWS's response type for {@code deletedPackage}, names the+ * package's name field {@code package}, not {@code name}: a different field name than+ * {@code PackageDescription} uses for the same data in {@code DescribePackage}'s response,+ * confirmed against the API reference.+ */+ private ObjectNode deletedPackageDescription(CodeArtifactService.PackageDescription described) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("format", described.format());+ if (described.namespace() != null) {+ node.put("namespace", described.namespace());+ }+ node.put("package", described.packageName());+ ObjectNode restrictions = node.putObject("originConfiguration").putObject("restrictions");+ restrictions.put("publish", described.publishRestriction());+ restrictions.put("upstream", described.upstreamRestriction());+ return node;+ }+private ObjectNode packageVersionDescription(CodeArtifactPackageVersion pv) {ObjectNode node = objectMapper.createObjectNode();node.put("format", pv.getFormat());diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.javaindex 4791418cc3..2c8d9549fc 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java@@ -712,12 +712,121 @@ public class CodeArtifactService implements Resettable {private boolean genericPackageExists(String region, String domain, String owner, String repository,String format, String namespace, String packageName) {+ return !genericPackageVersions(region, domain, owner, repository, format, namespace, packageName).isEmpty();+ }++ private List<CodeArtifactPackageVersion> genericPackageVersions(String region, String domain, String owner,+ String repository, String format, String namespace, String packageName) {String prefix = packageVersionKey(region, domain, repository, format, namespace, packageName, "");String wantedNamespace = namespace == null ? "" : namespace;return packageVersions.scanForAccount(owner, key -> key.startsWith(prefix)).stream()- .anyMatch(pv -> format.equals(pv.getFormat())+ .filter(pv -> format.equals(pv.getFormat())&& packageName.equals(pv.getPackageName())- && wantedNamespace.equals(pv.getNamespace() == null ? "" : pv.getNamespace()));+ && wantedNamespace.equals(pv.getNamespace() == null ? "" : pv.getNamespace()))+ .toList();+ }++ /**+ * Deletes a package and every one of its versions. A deleted package cannot be restored,+ * matching the real API's own documented behavior. Existence is checked where the package+ * actually lives, the same way {@link #describePackage} checks it, so a nonexistent package+ * answers {@code ResourceNotFoundException} rather than silently succeeding.+ *+ * <p>{@code synchronized} for the same reason {@link #publishPackageVersion} is: without a+ * shared lock, a publish and a delete racing the same generic package could interleave (a+ * version restored after its asset bytes are already gone, or a version published mid-scan+ * silently surviving or being dropped).+ */+ public synchronized PackageDescription deletePackage(String region, String domain, String domainOwner,+ String repository, String format, String namespace, String packageName) {+ if (format == null || !PACKAGE_FORMATS.contains(format)) {+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");+ }+ validatePackageToken("package", packageName);+ if (namespace != null) {+ validatePackageToken("namespace", namespace);+ }+ // Same boundary as describePackage's own namespace rules (see its comment there for the+ // API reference citation): a missing generic/maven namespace would delete under a+ // null-namespace key nothing real ever publishes to, and a supplied pypi namespace would+ // be silently ignored by the sidecar's existence check rather than rejected.+ if (("maven".equals(format) || "generic".equals(format)) && (namespace == null || namespace.isBlank())) {+ throw validation("namespace is required when deleting a " + format + " package.");+ }+ if ("pypi".equals(format) && namespace != null) {+ throw validation("pypi packages do not have a namespace.");+ }+ requireNonBlank(domain, "domain");+ requireNonBlank(repository, "repository");+ String owner = effectiveOwner(domainOwner);+ requireRepository(owner, repositoryKey(region, domain, repository), repository);+ if (CONTAINER_BACKED_FORMATS.contains(format)) {+ deleteContainerBackedPackage(region, domain, owner, repository, format, namespace, packageName);+ } else {+ List<CodeArtifactPackageVersion> versions = genericPackageVersions(region, domain, owner, repository,+ format, namespace, packageName);+ if (versions.isEmpty()) {+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");+ }+ for (CodeArtifactPackageVersion pv : versions) {+ String versionKey = packageVersionKey(region, domain, repository, format, namespace, packageName,+ pv.getVersion());+ // Metadata goes first: once the version record is gone, no caller can reach a+ // deleted asset's bytes through it regardless of whether the cleanup below+ // succeeds. Deleting bytes first and metadata last, if a later asset in the same+ // version failed to delete, would leave a surviving record pointing at bytes+ // already gone.+ packageVersions.deleteForAccount(owner, versionKey);+ for (PackageAsset asset : pv.getAssets().values()) {+ try {+ deleteAssetContent(owner, versionKey, asset.getName());+ } catch (UncheckedIOException e) {+ LOG.warnv(e, "Could not delete CodeArtifact asset file for {0}/{1}: {2}", versionKey,+ asset.getName(), e.getMessage());+ }+ }+ }+ }+ return new PackageDescription(format, namespace, packageName, "ALLOW", "BLOCK");+ }++ /**+ * Each sidecar's delete capability differs enough that there is no honest shared implementation:+ * Verdaccio and Reposilite remove a whole package in one call, while pypiserver's own management+ * endpoint only deletes one exact name/version pair per call, so {@code PypiserverSidecarClient}+ * lists every file first and removes each one in turn; all three are confirmed against live+ * containers. {@link RepositorySidecarManager#deletePackage}'s default still throws+ * {@link UnsupportedOperationException} for a sidecar that genuinely cannot do this, rather than+ * silently leaving the package in place or claiming a success it cannot back up; that becomes a+ * real, if deliberately blunt, AWS error here instead of an unhandled 500.+ */+ private void deleteContainerBackedPackage(String region, String domain, String owner, String repository,+ String format, String namespace, String packageName) {+ String repoId = ensureFormatContainerId(format, region, domain, owner, repository);+ RepositorySidecarManager manager = sidecarRegistry.forFormat(format)+ .orElseThrow(() -> notFound("Package '" + packageName + "' was not found.", packageName, "package"));+ if (!manager.packageExists(repoId, domain, repository, namespace, packageName)) {+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");+ }+ try {+ manager.deletePackage(repoId, domain, repository, namespace, packageName);+ } catch (UnsupportedOperationException e) {+ throw new AwsException("InternalServerException",+ "Deleting a " + format + " package is not yet supported by this emulator.", 500);+ }+ }++ private void deleteAssetContent(String owner, String packageVersionKey, String assetName) {+ if (inMemory) {+ memoryAssetStore.remove(assetStoreKey(owner, packageVersionKey, assetName));+ return;+ }+ Path filePath = resolveAssetPath(owner, packageVersionKey, assetName);+ try {+ Files.deleteIfExists(filePath);+ } catch (IOException e) {+ throw new UncheckedIOException("Failed to delete CodeArtifact asset file: " + filePath, e);+ }}public PackageVersionAssetResult getPackageVersionAsset(String region, String domain, String domainOwner,diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.javaindex ab2ea7359c..5307300dbb 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java@@ -1,17 +1,25 @@package io.github.hectorvent.floci.services.codeartifact;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import java.net.URI;+import java.net.URLEncoder;import java.net.http.HttpClient;import java.net.http.HttpRequest;+import java.net.http.HttpRequest.BodyPublishers;import java.net.http.HttpResponse;import java.net.http.HttpResponse.BodyHandlers;+import java.nio.charset.StandardCharsets;import java.time.Duration;+import java.util.LinkedHashSet;import java.util.List;import java.util.Locale;+import java.util.Map;import java.util.Optional;+import java.util.Set;import java.util.regex.Pattern;/**@@ -25,15 +33,17 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {private static final Pattern SIMPLE_INDEX_HREF = Pattern.compile("href=\"([^\"]*)\"");private final PypiserverSidecarManager manager;+ private final ObjectMapper mapper;private final HttpClient httpClient;@Inject- public PypiserverSidecarClient(PypiserverSidecarManager manager) {- this(manager, HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build());+ public PypiserverSidecarClient(PypiserverSidecarManager manager, ObjectMapper mapper) {+ this(manager, mapper, HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build());}- PypiserverSidecarClient(PypiserverSidecarManager manager, HttpClient httpClient) {+ PypiserverSidecarClient(PypiserverSidecarManager manager, ObjectMapper mapper, HttpClient httpClient) {this.manager = manager;+ this.mapper = mapper;this.httpClient = httpClient;}@@ -112,6 +122,111 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {return simpleIndex(baseUrl, packageName).isPresent();}+ /**+ * Removes a whole package, every version at once, confirmed against a live container: the pinned+ * image's management endpoint ({@code POST /} with {@code :action=remove_pkg}) deletes one exact+ * {@code name}/{@code version} pair per call rather than a whole package or project at once, so+ * every file is first listed from the same PyPI JSON API endpoint this image also serves+ * ({@code GET /<project>/json}, grouped by the same normalized project the simple index uses),+ * then each one removed in turn.+ *+ * <p>{@code name} for each call is recovered from the filename that endpoint listed, not from the+ * caller's {@code packageName}: {@code remove_pkg} matches against the literal, unnormalized name+ * the server itself derived when that file was uploaded, and an sdist and a wheel of the very same+ * release can legitimately differ there (a hyphen in one, an underscore in the other), so deleting+ * by one filename's recovered name alone can silently leave the other file behind.+ */+ @Override+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,+ String packageName) {+ String baseUrl = ensureReady(repositoryContainerId, null);+ for (PkgNameVersion file : packageFiles(baseUrl, packageName)) {+ removeVersion(baseUrl, file.name(), file.version());+ }+ }++ private record PkgNameVersion(String name, String version) {}++ private Set<PkgNameVersion> packageFiles(String baseUrl, String packageName) {+ String normalized = normalizePackageName(packageName);+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + SidecarUriUtils.encodeSegment(normalized)+ + "/json");+ HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).GET().build();+ HttpResponse<String> response;+ try {+ response = httpClient.send(request, BodyHandlers.ofString());+ } catch (Exception e) {+ throw new IllegalStateException("Could not reach the pypiserver sidecar to list versions of "+ + packageName, e);+ }+ if (response.statusCode() == 404) {+ return Set.of();+ }+ if (response.statusCode() != 200) {+ throw new IllegalStateException("Could not list versions of " + packageName + " on the pypiserver "+ + "sidecar: upstream returned " + response.statusCode());+ }+ JsonNode releases;+ try {+ releases = mapper.readTree(response.body()).path("releases");+ } catch (Exception e) {+ throw new IllegalStateException("Could not parse pypiserver's version listing for " + packageName, e);+ }+ Set<PkgNameVersion> files = new LinkedHashSet<>();+ for (Map.Entry<String, JsonNode> release : releases.properties()) {+ String version = release.getKey();+ for (JsonNode file : release.getValue()) {+ String url = file.path("url").asText("");+ String filename = url.substring(url.lastIndexOf('/') + 1);+ files.add(new PkgNameVersion(rawPkgname(filename, version), version));+ }+ }+ return files;+ }++ /**+ * The exact, unnormalized name pypiserver's own {@code remove_pkg} needs for {@code filename}, at+ * known version {@code version}: the text of {@code filename} up to (but not including) the+ * {@code -<version>} marker that {@link #versionBoundaryEndsAt} confirms really ends the version+ * field there, the same boundary {@link #filenameEmbedsVersion} already relies on. Falls back to+ * the whole filename in the (not expected in practice) case nothing satisfies that boundary: a+ * harmless no-op for {@code remove_pkg}, since no file was ever uploaded under that literal name.+ */+ private static String rawPkgname(String filename, String version) {+ String marker = "-" + version;+ for (int idx = filename.indexOf(marker); idx >= 0; idx = filename.indexOf(marker, idx + 1)) {+ if (versionBoundaryEndsAt(filename, idx + marker.length())) {+ return filename.substring(0, idx);+ }+ }+ return filename;+ }++ private void removeVersion(String baseUrl, String pkgname, String version) {+ String body = "%3Aaction=remove_pkg"+ + "&name=" + URLEncoder.encode(pkgname, StandardCharsets.UTF_8)+ + "&version=" + URLEncoder.encode(version, StandardCharsets.UTF_8);+ HttpRequest request = HttpRequest.newBuilder(URI.create(baseUrl))+ .timeout(Duration.ofSeconds(10))+ .header("Content-Type", "application/x-www-form-urlencoded")+ .POST(BodyPublishers.ofString(body))+ .build();+ HttpResponse<String> response;+ try {+ response = httpClient.send(request, BodyHandlers.ofString());+ } catch (Exception e) {+ throw new IllegalStateException("Could not reach the pypiserver sidecar to delete " + pkgname + " "+ + version, e);+ }+ // 404 means remove_pkg found nothing for this exact name/version: already removed by an+ // earlier call in this same loop for a sibling file that happened to share it, not a real+ // failure.+ if (response.statusCode() != 200 && response.statusCode() != 404) {+ throw new IllegalStateException("Could not delete " + pkgname + " " + version + " from the "+ + "pypiserver sidecar: upstream returned " + response.statusCode());+ }+ }+private Optional<String> simpleIndex(String baseUrl, String packageName) {String normalized = normalizePackageName(packageName);URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/simple/" + SidecarUriUtils.encodeSegment(normalized)diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.javaindex d2c0172a9a..18f4e8ffde 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java@@ -131,12 +131,8 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {public boolean packageExists(String repositoryContainerId, String domain, String repository, String namespace,String packageName) {String baseUrl = manager.ensureReady();- StringBuilder path = new StringBuilder("/").append(SidecarUriUtils.encodeSegment(repositoryContainerId));- for (String namespacePart : namespace.split("\\.", -1)) {- path.append('/').append(SidecarUriUtils.encodeSegment(namespacePart));- }- path.append('/').append(SidecarUriUtils.encodeSegment(packageName)).append('/');- HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), path.toString()))+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl),+ packageDirectoryPath(repositoryContainerId, namespace, packageName))).timeout(Duration.ofSeconds(30)).header("Authorization", manager.basicAuthHeader()).GET()@@ -152,6 +148,39 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {return true;}+ /**+ * Removes a whole package, every version at once: a single {@code DELETE} on the group/artifact+ * directory. Confirmed against a live Reposilite container: it recursively removes everything+ * beneath that path in one call. {@link #packageExists} is checked by the caller first, since+ * Reposilite answers a confusing HTTP 500 for a {@code DELETE} on a path that was never there,+ * not a 404.+ */+ @Override+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,+ String packageName) {+ String baseUrl = manager.ensureReady();+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl),+ packageDirectoryPath(repositoryContainerId, namespace, packageName)))+ .timeout(Duration.ofSeconds(30))+ .header("Authorization", manager.basicAuthHeader())+ .DELETE()+ .build();+ HttpResponse<Void> response = send(request, BodyHandlers.discarding());+ if (response.statusCode() != 200) {+ throw new IllegalStateException("Could not delete " + packageName+ + " from the Reposilite sidecar: upstream returned " + response.statusCode());+ }+ }++ private static String packageDirectoryPath(String repositoryContainerId, String namespace, String packageName) {+ StringBuilder path = new StringBuilder("/").append(SidecarUriUtils.encodeSegment(repositoryContainerId));+ for (String namespacePart : namespace.split("\\.", -1)) {+ path.append('/').append(SidecarUriUtils.encodeSegment(namespacePart));+ }+ path.append('/').append(SidecarUriUtils.encodeSegment(packageName)).append('/');+ return path.toString();+ }+/** Ensures a Reposilite repository named {@code repoId} exists, creating it if not. */public void ensureRepository(String repoId) {String baseUrl = manager.ensureReady();diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.javaindex 293a2f37a7..4d5f38ae6c 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java@@ -64,4 +64,16 @@ public interface RepositorySidecarManager {*/boolean packageExists(String repositoryContainerId, String domain, String repository, String namespace,String packageName);++ /**+ * Deletes every version of the named package from this sidecar's own backing storage. Every+ * sidecar Floci currently backs (Reposilite, Verdaccio, pypiserver) can do this; the default+ * throws {@link UnsupportedOperationException} rather than silently leaving the package in place+ * or claiming a success it cannot back up, for a future format whose sidecar genuinely cannot. An+ * implementation that can delete overrides this.+ */+ default void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,+ String packageName) {+ throw new UnsupportedOperationException(format() + " packages cannot be deleted through this sidecar");+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.javaindex 859c1095dd..8c4139f27a 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java@@ -100,6 +100,36 @@ public class VerdaccioSidecarClient implements RepositorySidecarManager {return fetchPackageDocument(baseUrl, namespace, packageName).isPresent();}+ /**+ * Removes a whole package, every version at once, the same way the real npm CLI's final+ * unpublish step does: fetch the packument for its current {@code _rev}, then {@code DELETE} the+ * package path with that revision appended as {@code /-rev/<rev>}. Confirmed against a live+ * Verdaccio container: a bare {@code DELETE} with no revision is not a route at all (404+ * "Cannot DELETE"), and the revisioned form removes every version and tarball in one call.+ */+ @Override+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,+ String packageName) {+ String baseUrl = ensureReady(repositoryContainerId, publicUrl(domain, repository));+ String revision = fetchPackageDocument(baseUrl, namespace, packageName)+ .orElseThrow(() -> new IllegalStateException(packageName + " no longer exists on the Verdaccio "+ + "sidecar"))+ .path("_rev").asText("");+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + packagePath(namespace, packageName)+ + "/-rev/" + SidecarUriUtils.encodeSegment(revision));+ HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).DELETE().build();+ HttpResponse<Void> response;+ try {+ response = httpClient.send(request, BodyHandlers.discarding());+ } catch (Exception e) {+ throw new IllegalStateException("Could not reach the Verdaccio sidecar to delete " + packageName, e);+ }+ if (response.statusCode() != 200 && response.statusCode() != 201) {+ throw new IllegalStateException("Could not delete " + packageName+ + " from the Verdaccio sidecar: upstream returned " + response.statusCode());+ }+ }+/** One tarball by its filename, from a backend already made ready by {@link #ensureReady}. */public Optional<byte[]> fetchTarball(String baseUrl, String namespace, String packageName, String assetName) {HttpRequest request = tarballRequest(baseUrl, namespace, packageName, assetName);diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.javaindex 92f1e8b141..d2d473b060 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java@@ -17,11 +17,14 @@ import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;import java.io.IOException;+import java.io.UncheckedIOException;import java.nio.charset.StandardCharsets;import java.nio.file.AccessDeniedException;+import java.nio.file.DirectoryNotEmptyException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.attribute.BasicFileAttributes;+import java.util.Arrays;import java.util.Base64;import java.util.List;import java.util.Map;@@ -355,6 +358,63 @@ class CodeArtifactAssetPersistenceTest {assertEquals("a.txt", e.getExtendedData().get("resourceId"));}+ /**+ * {@code deletePackage} removes a version's metadata record before it attempts to clean up+ * that version's asset bytes, specifically so a cleanup failure on one asset never leaves the+ * record in place pointing at bytes that may now be missing. A {@link DirectoryNotEmptyException}+ * forced on one asset's path stands in for the failure here, since it is deterministic and+ * platform-independent (unlike a permission trick, which a root-run CI container would ignore).+ * The other asset in the same version must still get cleaned up, and the failure must be logged+ * rather than silently swallowed, the same way {@code republishingWithMatchingContentRepairsAnUnreadableBackingFileAndLogsAWarning}+ * above asserts on the real log record rather than trusting that the behavior exists.+ */+ @Test+ void deletingAnAssetsBytesFailingStillRemovesTheVersionRecordAndCleansUpTheOtherAsset(@TempDir Path dir)+ throws IOException {+ CodeArtifactService service = newService(dir);+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] contentA = "content of a".getBytes(StandardCharsets.UTF_8);+ byte[] contentB = "content of b".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",+ sha256Hex(contentA), "true", contentA);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "b.txt",+ sha256Hex(contentB), "true", contentB);++ Path assetFileA;+ Path assetFileB;+ try (Stream<Path> paths = Files.walk(dir.resolve("codeartifact-assets"))) {+ List<Path> files = paths.filter(Files::isRegularFile).toList();+ assetFileA = files.stream().filter(p -> matchesContent(p, contentA)).findFirst().orElseThrow();+ assetFileB = files.stream().filter(p -> matchesContent(p, contentB)).findFirst().orElseThrow();+ }+ Files.delete(assetFileB);+ Files.createDirectory(assetFileB);+ Files.createFile(assetFileB.resolve("not-empty"));++ List<LogRecord> records = LogCapture.capture(CodeArtifactService.class, () ->+ service.deletePackage(REGION, "dom", null, "repo", "generic", "ns", "my-pkg"));++ assertTrue(records.stream().anyMatch(r -> r.getMessage() != null+ && r.getMessage().contains("Could not delete CodeArtifact asset file")+ && r.getThrown() instanceof UncheckedIOException+ && r.getThrown().getCause() instanceof DirectoryNotEmptyException),+ "expected a warning logging the failed asset cleanup, got: " + records);+ assertFalse(Files.exists(assetFileA), "the other asset's bytes must still be cleaned up");++ AwsException gone = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION, "dom",+ null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt", null));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());+ }++ private static boolean matchesContent(Path file, byte[] expected) {+ try {+ return Arrays.equals(Files.readAllBytes(file), expected);+ } catch (IOException e) {+ return false;+ }+ }+@Testvoid distinctAssetNamesNeverCollideOnDisk(@TempDir Path dir) {CodeArtifactService service = newService(dir);diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.javaindex c5ee800a99..d6e72f1867 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java@@ -211,6 +211,45 @@ class CodeArtifactIntegrationTest {.then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));}+ @Test+ void deletePackageUsesThePackageFieldNameAndRemovesEveryVersion() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=delete-domain").then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=delete-domain&repository=repo").then().statusCode(200);+ byte[] content = "delete-me".getBytes(StandardCharsets.UTF_8);+ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256Hex(content))+ .contentType("application/octet-stream").body(content)+ .post("/v1/package/version/publish?domain=delete-domain&repository=repo&format=generic"+ + "&namespace=ns&package=my-pkg&version=1.0.0&asset=a.txt")+ .then().statusCode(200);++ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"+ + "&package=my-pkg")+ .then().statusCode(200)+ .body("deletedPackage.format", equalTo("generic"))+ .body("deletedPackage.namespace", equalTo("ns"))+ .body("deletedPackage.package", equalTo("my-pkg"))+ .body("deletedPackage.originConfiguration.restrictions.publish", equalTo("ALLOW"))+ .body("deletedPackage.originConfiguration.restrictions.upstream", equalTo("BLOCK"));++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"+ + "&package=my-pkg")+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));++ given().header("Authorization", AUTH)+ .get("/v1/package/version/asset?domain=delete-domain&repository=repo&format=generic&namespace=ns"+ + "&package=my-pkg&version=1.0.0&asset=a.txt")+ .then().statusCode(404);++ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"+ + "&package=my-pkg")+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }+@Testvoid unfinishedPublishKeepsVersionOpenForMoreAssets() {given().contentType("application/json").header("Authorization", AUTH)diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.javaindex 1741a4a189..26db2d46c2 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java@@ -409,6 +409,35 @@ class CodeArtifactMavenDockerIntegrationTest {.then().statusCode(404);}+ /**+ * A throwaway groupId/artifactId, not {@link #GAV}: deleting it exercises Reposilite's real+ * directory delete (confirmed live before this was built: a single {@code DELETE} on the+ * group/artifact path removes everything beneath it), and must not disturb the artifact every+ * other test in this class shares.+ */+ @Test+ @Order(13)+ void deletePackageRemovesTheWholeReposiliteArtifactDirectory() {+ byte[] content = "delete-me-bytes".getBytes(StandardCharsets.UTF_8);+ given().header("Authorization", "Bearer " + bearerToken).body(content)+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/deleteme/1.0.0/deleteme-1.0.0.jar")+ .then().statusCode(200);++ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=maven"+ + "&namespace=com.example&package=deleteme")+ .then().statusCode(200).body("deletedPackage.package", equalTo("deleteme"));++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/deleteme/1.0.0/deleteme-1.0.0.jar")+ .then().statusCode(404);++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=maven"+ + "&namespace=com.example&package=deleteme")+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }+/*** Reads the real Reposilite instance's own {@code maven} settings domain directly (the same* shared container {@link ReposiliteSidecarManager} started for every test in this class).diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.javaindex 1a2924b13f..615df40cc9 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java@@ -339,6 +339,40 @@ class CodeArtifactNpmDockerIntegrationTest {.then().statusCode(404);}+ /**+ * A throwaway package, not {@link #PACKAGE_NAME}: deleting it exercises the real Verdaccio+ * unpublish-whole-package mechanism (GET the packument's own {@code _rev}, then {@code DELETE}+ * with that revision), confirmed live before this was built, and must not disturb the package+ * every other test in this class shares.+ */+ @Test+ @Order(11)+ void deletePackageRemovesTheWholeVerdaccioPackage() {+ String packageName = "delete-me-pkg";+ byte[] tarball = "throwaway tarball".getBytes(StandardCharsets.UTF_8);+ String envelope = "{\"name\":\"" + packageName + "\",\"versions\":{\"1.0.0\":{\"name\":\"" + packageName+ + "\",\"version\":\"1.0.0\",\"dist\":{\"tarball\":\"http://ignored/" + packageName + "-1.0.0.tgz\""+ + "}}},\"_attachments\":{\"" + packageName + "-1.0.0.tgz\":{\"content_type\":"+ + "\"application/octet-stream\",\"data\":\""+ + Base64.getEncoder().encodeToString(tarball) + "\",\"length\":" + tarball.length + "}}}";++ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(envelope)+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)+ .then().statusCode(anyOf201Or200());++ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=npm&package=" + packageName)+ .then().statusCode(200).body("deletedPackage.package", equalTo(packageName));++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)+ .then().statusCode(404);++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=npm&package=" + packageName)+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }+/*** Proves the actual mechanism, not just that {@code VerdaccioSidecarManager} has a method* named right: {@code ContainerTeardowns.stopAll} runs every {@code ContainerTeardown} ondiff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.javaindex 90a5b2c390..6c34820347 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java@@ -356,6 +356,36 @@ class CodeArtifactPypiDockerIntegrationTest {.then().statusCode(404);}+ /**+ * pypiserver has no single whole-package delete route the way Verdaccio and Reposilite do, but+ * its own management endpoint ({@code POST /} with {@code :action=remove_pkg}) does delete a+ * named version for real, confirmed live: {@code DeletePackage} lists every version through+ * that same container and removes each one, so this asserts the real removal rather than a+ * refusal, and that the file this class's earlier tests uploaded is genuinely gone afterward.+ */+ @Test+ @Order(13)+ void deletePackageRemovesTheFileFromTheRealPypiserverSidecar() {+ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi&package="+ + PACKAGE_NAME)+ .then().statusCode(200).body("deletedPackage.package", equalTo(PACKAGE_NAME));++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/simple/" + PACKAGE_NAME + "/")+ .then().statusCode(404);++ given().header("Authorization", AUTH)+ .get("/v1/package/version/asset?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi"+ + "&package=" + PACKAGE_NAME + "&version=1.0.0&asset=" + FILENAME)+ .then().statusCode(404);++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi&package="+ + PACKAGE_NAME)+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }+/*** Proves the actual mechanism, not just that {@code PypiserverSidecarManager} has a method* named right: {@code ContainerTeardowns.stopAll} runs every {@code ContainerTeardown} ondiff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.javaindex db4ed3ad6d..5ddc798bcb 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java@@ -1104,6 +1104,144 @@ class CodeArtifactServiceTest {assertEquals("ValidationException", e.getErrorCode());}+ @Test+ void deletePackageRemovesEveryVersionAndAssetButLeavesOtherPackagesAlone() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "2.0.0", "a.txt",+ sha256Hex(content), "false", content);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "other-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);++ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo",+ "generic", "ns", "my-pkg");+ assertEquals("generic", deleted.format());+ assertEquals("ns", deleted.namespace());+ assertEquals("my-pkg", deleted.packageName());++ AwsException goneAsPackage = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom",+ null, "repo", "generic", "ns", "my-pkg"));+ assertEquals("ResourceNotFoundException", goneAsPackage.getErrorCode());+ AwsException goneVersionOne = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,+ "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt", null));+ assertEquals("ResourceNotFoundException", goneVersionOne.getErrorCode());+ AwsException goneVersionTwo = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,+ "dom", null, "repo", "generic", "ns", "my-pkg", "2.0.0", "a.txt", null));+ assertEquals("ResourceNotFoundException", goneVersionTwo.getErrorCode());++ CodeArtifactService.PackageDescription stillThere = service.describePackage(REGION, "dom", null, "repo",+ "generic", "ns", "other-pkg");+ assertEquals("other-pkg", stillThere.packageName());++ AwsException alreadyDeleted = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom",+ null, "repo", "generic", "ns", "my-pkg"));+ assertEquals("ResourceNotFoundException", alreadyDeleted.getErrorCode());++ AwsException unknown = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null,+ "repo", "generic", "ns", "no-such-package"));+ assertEquals("ResourceNotFoundException", unknown.getErrorCode());+ }++ @Test+ void deletePackageBridgesToReposiliteForMavenAfterConfirmingItExists() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository created =+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ String repoId = created.getSidecarContainerIds().get("maven");+ when(reposiliteClient.packageExists(eq(repoId), eq("dom"), eq("repo"), eq("com.example"),+ eq("my-artifact"))).thenReturn(true);++ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo", "maven",+ "com.example", "my-artifact");++ assertEquals("maven", deleted.format());+ verify(reposiliteClient).deletePackage(repoId, "dom", "repo", "com.example", "my-artifact");+ }++ @Test+ void deletePackageReportsNotFoundForAContainerBackedPackageThatDoesNotExistRatherThanDeletingAnything() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ when(verdaccioClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg")))+ .thenReturn(false);++ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",+ "npm", null, "my-pkg"));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ verify(verdaccioClient, never()).deletePackage(any(), any(), any(), any(), any());+ }++ /**+ * {@link RepositorySidecarManager#deletePackage}'s default throws+ * {@link UnsupportedOperationException} for a sidecar that genuinely cannot delete (every sidecar+ * Floci actually backs can, but the service must still handle one that can't, present or future);+ * this stubs that default's own throw straight onto the mock to exercise it without needing a+ * real sidecar that refuses. The service must not let it propagate as an unhandled 500: it+ * becomes a real, if deliberately blunt, documented AWS error instead.+ */+ @Test+ void deletePackageTranslatesAnUnsupportedSidecarDeleteIntoAnInternalServerException() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ when(pypiserverClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg")))+ .thenReturn(true);+ doThrow(new UnsupportedOperationException("pypi packages cannot be deleted through this sidecar"))+ .when(pypiserverClient).deletePackage(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg"));++ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",+ "pypi", null, "my-pkg"));+ assertEquals("InternalServerException", e.getErrorCode());+ }++ /**+ * Mirrors describePackage's own boundary-validation test: deletePackage must reject the same+ * malformed coordinates before touching repository state, not just the single maven-namespace+ * check it had before this test existed.+ */+ @Test+ void deletePackageValidatesPackageAndNamespaceShapeBeforeTouchingRepositoryState() {+ AwsException badPackageName = assertThrows(AwsException.class, () -> service.deletePackage(REGION,+ "no-such-domain", null, "repo", "generic", "ns", "has/slash"));+ assertEquals("ValidationException", badPackageName.getErrorCode());++ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ AwsException badNamespace = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom",+ null, "repo", "generic", "has#hash", "my-pkg"));+ assertEquals("ValidationException", badNamespace.getErrorCode());++ AwsException missingNamespaceForGeneric = assertThrows(AwsException.class, () -> service.deletePackage(+ REGION, "dom", null, "repo", "generic", null, "my-pkg"));+ assertEquals("ValidationException", missingNamespaceForGeneric.getErrorCode());++ AwsException missingNamespaceForMaven = assertThrows(AwsException.class, () -> service.deletePackage(+ REGION, "dom", null, "repo", "maven", null, "my-artifact"));+ assertEquals("ValidationException", missingNamespaceForMaven.getErrorCode());+ }++ /**+ * pypi packages have no namespace at all (same API-reference fact describePackage's own test+ * documents). Without this rejection, a caller-supplied namespace would be silently ignored by+ * the sidecar's existence check below and the real package would be deleted anyway, as if the+ * namespace the caller specified had actually been honored.+ */+ @Test+ void deletePackageRejectsANamespaceSuppliedForPypiRatherThanDeletingTheRealPackageAnyway() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ when(pypiserverClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("real-pkg")))+ .thenReturn(true);++ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",+ "pypi", "bogus-namespace", "real-pkg"));+ assertEquals("ValidationException", e.getErrorCode());+ verify(pypiserverClient, never()).deletePackage(any(), any(), any(), any(), any());+ }+@Testvoid getPackageVersionAssetReturnsExactBytesAndValidatesRevision() {service.createDomain(REGION, "dom", null, Map.of());diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.javaindex 69cfa66527..2fef9e662b 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.codeartifact;+import com.fasterxml.jackson.databind.ObjectMapper;import com.sun.net.httpserver.HttpServer;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;@@ -13,8 +14,11 @@ import java.lang.reflect.Field;import java.net.InetSocketAddress;import java.net.http.HttpClient;import java.nio.charset.StandardCharsets;+import java.util.List;+import java.util.Map;import java.util.Optional;import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.CopyOnWriteArrayList;import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -374,6 +378,128 @@ class PypiserverSidecarClientTest {assertEquals("/simple/a%2F-%2Fb/", observedRawPath.get());}+ /**+ * Confirmed live: pypiserver's own management endpoint ({@code POST /} with+ * {@code :action=remove_pkg}) only deletes one exact name/version pair per call, matched+ * against the literal, unnormalized name it derived from the uploaded filename, not the PEP 503+ * normalized form the simple index uses. An sdist and a wheel of the very same release can+ * legitimately differ there ({@code demo-pkg} versus {@code demo_pkg}), so this proves+ * {@code deletePackage} recovers each file's own name from the JSON listing and removes both,+ * rather than deleting by one shared name and silently leaving the other file behind.+ */+ @Test+ void deletePackageRemovesEveryFileUnderItsOwnRecoveredNameNotOneSharedName() throws Exception {+ PypiserverSidecarManager manager = manager();+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);+ respondWithJsonReleases("demo-pkg",+ Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz", "demo_pkg-1.0.0-py3-none-any.whl")));+ List<String> removeBodies = new CopyOnWriteArrayList<>();+ backend.createContext("/", exchange -> {+ removeBodies.add(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));+ exchange.sendResponseHeaders(200, -1);+ exchange.close();+ });++ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");++ assertEquals(2, removeBodies.size());+ assertTrue(removeBodies.stream().anyMatch(b -> b.contains("name=demo-pkg") && b.contains("version=1.0.0")),+ "expected a remove_pkg call for the sdist's own name: " + removeBodies);+ assertTrue(removeBodies.stream().anyMatch(b -> b.contains("name=demo_pkg") && b.contains("version=1.0.0")),+ "expected a remove_pkg call for the wheel's own name: " + removeBodies);+ }++ /**+ * A 404 from {@code remove_pkg} means it matched nothing for that exact name/version, which+ * happens for real when an earlier call in the same {@code deletePackage} loop already removed+ * every file sharing it; {@code deletePackage} must treat that as already done, not a failure.+ */+ @Test+ void deletePackageToleratesANotFoundResponseFromRemovePkgAsAlreadyRemoved() throws Exception {+ PypiserverSidecarManager manager = manager();+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);+ respondWithJsonReleases("demo-pkg", Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz")));+ backend.createContext("/", exchange -> {+ exchange.sendResponseHeaders(404, -1);+ exchange.close();+ });++ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");+ }++ /** A package with no releases at all deletes nothing and does not fail. */+ @Test+ void deletePackageIsANoOpForAPackageThatWasNeverUploaded() throws Exception {+ PypiserverSidecarManager manager = manager();+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);+ backend.createContext("/demo-pkg/json", exchange -> {+ exchange.sendResponseHeaders(404, -1);+ exchange.close();+ });+ backend.createContext("/", exchange -> {+ exchange.sendResponseHeaders(500, -1);+ exchange.close();+ });++ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");+ }++ @Test+ void deletePackageThrowsRatherThanReportingNotFoundWhenListingVersionsFails() throws Exception {+ PypiserverSidecarManager manager = manager();+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);+ backend.createContext("/demo-pkg/json", exchange -> {+ exchange.sendResponseHeaders(500, -1);+ exchange.close();+ });++ assertThrows(IllegalStateException.class,+ () -> client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg"));+ }++ @Test+ void deletePackageThrowsRatherThanReportingNotFoundOnARemovePkgServerError() throws Exception {+ PypiserverSidecarManager manager = manager();+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);+ respondWithJsonReleases("demo-pkg", Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz")));+ backend.createContext("/", exchange -> {+ exchange.sendResponseHeaders(500, -1);+ exchange.close();+ });++ assertThrows(IllegalStateException.class,+ () -> client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg"));+ }++ private void respondWithJsonReleases(String packageName, Map<String, List<String>> releases) {+ StringBuilder json = new StringBuilder("{\"info\":{\"version\":\"\"},\"releases\":{");+ boolean firstVersion = true;+ for (Map.Entry<String, List<String>> release : releases.entrySet()) {+ if (!firstVersion) {+ json.append(',');+ }+ firstVersion = false;+ json.append('"').append(release.getKey()).append("\":[");+ boolean firstFile = true;+ for (String filename : release.getValue()) {+ if (!firstFile) {+ json.append(',');+ }+ firstFile = false;+ json.append("{\"url\":\"/packages/").append(filename).append("\"}");+ }+ json.append(']');+ }+ json.append("}}");+ byte[] bytes = json.toString().getBytes(StandardCharsets.UTF_8);+ backend.createContext("/" + packageName + "/json", exchange -> {+ exchange.getResponseHeaders().set("Content-Type", "application/json");+ exchange.sendResponseHeaders(200, bytes.length);+ exchange.getResponseBody().write(bytes);+ exchange.close();+ });+ }+private void respondWithSimpleIndex(String packageName, String filename) {String html = "<a href=\"/packages/" + filename + "\">" + filename + "</a>";backend.createContext("/simple/" + packageName + "/", exchange -> {@@ -390,7 +516,7 @@ class PypiserverSidecarClientTest {}private PypiserverSidecarClient client(PypiserverSidecarManager manager) {- return new PypiserverSidecarClient(manager, HttpClient.newHttpClient());+ return new PypiserverSidecarClient(manager, new ObjectMapper(), HttpClient.newHttpClient());}@SuppressWarnings("unchecked")diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.javaindex 275a4a0c45..2209619551 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java@@ -578,6 +578,27 @@ class ReposiliteSidecarClientTest {"com.example", "broken"));}+ @Test+ void deletePackageSendsADeleteToTheGroupArtifactDirectory() {+ AtomicReference<String> deletedPath = new AtomicReference<>();+ server.createContext("/dom--repo/com/example/gone/", exchange -> {+ deletedPath.set(exchange.getRequestURI().toString());+ respond(exchange, 200, "");+ });++ client.deletePackage("dom--repo", "dom", "repo", "com.example", "gone");++ assertThat(deletedPath.get(), equalTo("/dom--repo/com/example/gone/"));+ }++ @Test+ void deletePackageThrowsWhenTheSidecarAnswersWithAnUnexpectedStatus() {+ server.createContext("/dom--repo/com/example/weird/", exchange -> respond(exchange, 500, ""));++ assertThrows(IllegalStateException.class, () -> client.deletePackage("dom--repo", "dom", "repo",+ "com.example", "weird"));+ }+private static void respond(HttpExchange exchange, int status, String body) throws IOException {byte[] bytes = body.getBytes(StandardCharsets.UTF_8);exchange.sendResponseHeaders(status, bytes.length);diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.javaindex 999e3d4571..b03cb4bdb4 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java@@ -197,6 +197,54 @@ class VerdaccioSidecarClientTest {assertEquals("/%2E%2E", observedRawPath.get());}+ /**+ * Mirrors the real npm unpublish mechanism, confirmed against a live Verdaccio container: GET+ * the packument for its {@code _rev}, then {@code DELETE} the package path with that revision+ * appended as {@code /-rev/<rev>}.+ */+ @Test+ void deletePackageFetchesTheRevisionThenDeletesWithIt() throws Exception {+ VerdaccioSidecarManager manager = manager();+ seedPooledContainer(manager, "npm-repo-1", "tracked-verdaccio-1", backendUrl);+ backend.createContext("/demo-pkg", exchange -> {+ byte[] bytes = "{\"_rev\":\"3-abc123\"}".getBytes(StandardCharsets.UTF_8);+ exchange.getResponseHeaders().set("Content-Type", "application/json");+ exchange.sendResponseHeaders(200, bytes.length);+ exchange.getResponseBody().write(bytes);+ exchange.close();+ });+ AtomicReference<String> deletePath = new AtomicReference<>();+ backend.createContext("/demo-pkg/-rev/3-abc123", exchange -> {+ deletePath.set(exchange.getRequestURI().toString());+ exchange.sendResponseHeaders(201, -1);+ exchange.close();+ });++ client(manager).deletePackage("npm-repo-1", "dom", "repo", null, "demo-pkg");++ assertEquals("/demo-pkg/-rev/3-abc123", deletePath.get());+ }++ @Test+ void deletePackageThrowsWhenTheSidecarRejectsTheDelete() throws Exception {+ VerdaccioSidecarManager manager = manager();+ seedPooledContainer(manager, "npm-repo-1", "tracked-verdaccio-1", backendUrl);+ backend.createContext("/demo-pkg", exchange -> {+ byte[] bytes = "{\"_rev\":\"3-abc123\"}".getBytes(StandardCharsets.UTF_8);+ exchange.getResponseHeaders().set("Content-Type", "application/json");+ exchange.sendResponseHeaders(200, bytes.length);+ exchange.getResponseBody().write(bytes);+ exchange.close();+ });+ backend.createContext("/demo-pkg/-rev/3-abc123", exchange -> {+ exchange.sendResponseHeaders(409, -1);+ exchange.close();+ });++ assertThrows(IllegalStateException.class, () -> client(manager).deletePackage("npm-repo-1", "dom", "repo",+ null, "demo-pkg"));+ }+private void respondWithMetadata(String packagePath, String version, String tarballPath) {String body = "{\"versions\":{\"" + version + "\":{\"dist\":{\"tarball\":\"http://ignored" + tarballPath+ "\"}}}}";