Ingot (smelt forge stack)

GetBucketAcl on a non-existing bucket returns NoSuchBucket

Anonymous PutObject to a private bucket returns AccessDenied

DeleteBucket succeeds once, then repeating it returns NoSuchBucket

CreateBucket on a name owned by another user returns BucketAlreadyExists

CreateBucket with a one-character name returns InvalidBucketName

CreateBucket with a two-character name returns InvalidBucketName

DeleteBucket on a non-empty bucket returns BucketNotEmpty

DeleteBucket on a nonexistent bucket returns NoSuchBucket

HeadBucket on an existing bucket returns 200

HeadBucket on a nonexistent bucket returns 404

ListObjects on a nonexistent bucket returns NoSuchBucket

ListBuckets includes every created bucket

ListObjectsV2 on a nonexistent bucket returns NoSuchBucket

CreateBucket succeeds for a name containing a hyphen

CreateBucket succeeds for a name containing a period

CreateBucket succeeds for a name starting with a lowercase letter

CreateBucket succeeds for a name starting with a digit

ListBuckets with an unknown access key is rejected with 403

Created bucket appears in ListBuckets and HeadBucket returns 404 after deletion

Bucket creation is covered by the prerequisite; the final not-in-list assertion of the source test is expressed as HeadBucket returning 404 after DeleteBucket.

CreateBucket rejects invalid bucket names

Server-side bucket-naming rules: uppercase, underscores, leading/trailing hyphens, consecutive dots, dot-hyphen sequences, IP-address form, xn-- prefix, reserved -s3alias/--ol-s3 affixes and length limits (3-63). Original test accepted any rejection error; AWS returns InvalidBucketName. Name cases that common SDKs reject client-side (empty, space, slash, punctuation) were dropped, as were the tolerant valid-name and reserved-prefix branches that pass on either outcome; the duplicate-name check is covered by the CreateBucket-on-existing-bucket vector.

CreateBucket on an existing bucket you own returns BucketAlreadyOwnedByYou

Original test also accepted BucketAlreadyExists. Note that AWS us-east-1 has legacy behavior returning 200 for re-creating a bucket you own.

CreateBucket succeeds and the bucket is accessible via HeadBucket

Full bucket lifecycle: create, put and read an object, delete object, delete bucket

DeleteBucket removes the bucket

GetBucketLocation on a non-existent bucket returns NoSuchBucket

GetBucketLocation succeeds on an existing bucket

Original test only asserted the LocationConstraint key was present in the boto3 response shape (it is null for us-east-1), so this vector asserts the call succeeds.

ListBuckets returns a Buckets list

ListBuckets includes created buckets

Empty bucket lists zero keys and can be deleted

ListBuckets rejects a negative max-buckets value

Raw HTTP so the out-of-range value reaches the server rather than being caught client-side. AWS's valid MaxBuckets range is 1-10000 and a negative value is rejected with InvalidArgument. The original also probed an over-large value (2000000) but its primary branch accepted success (some implementations cap silently) and only tolerated rejection as an alternative; that undecidable success-or-error case is omitted.

ListBuckets MaxBuckets truncates the listing and ContinuationToken resumes it

Six runner-provisioned buckets guarantee the account holds more than MaxBuckets=3 buckets, so the first page must be truncated. The original tolerated implementations without pagination support.

ListBuckets with Prefix returns only buckets whose names match the prefix

Buckets are created in steps as suffixes of the runner-provisioned bucket name so the prefix is unique to this vector. The original tolerated implementations that ignore Prefix (MinIO); this vector asserts the AWS filtering behavior.

GetObjectAttributes on a SHA256-checksummed single-part object reports size, ETag, storage class and checksum with no ObjectParts

GetObjectAttributes on a SHA256-checksummed 13-part multipart object reports size, composite checksum and per-part checksums

PutObject with CRC64NVME checksum: echoed on put, hidden on plain HEAD, shown with ChecksumMode, bad digest rejected

PutObject with SHA256 checksum: echoed on put, hidden on plain HEAD, shown with ChecksumMode, bad digest rejected

Object uploaded with ChecksumAlgorithm SHA256 is retrievable with intact body

HeadObject with ChecksumMode=ENABLED returns the CRC32 checksum from PutObject

HeadObject with ChecksumMode=ENABLED returns the SHA1 checksum from PutObject

HeadObject with ChecksumMode=ENABLED returns the SHA256 checksum from PutObject

PutObject with an incorrect ChecksumSHA256 returns BadDigest

The supplied checksum is a valid base64 32-byte value that does not match the body. The original test accepts several codes (InvalidRequest, BadDigest, XAmzContentSHA256Mismatch, XAmzContentChecksumMismatch); AWS returns BadDigest.

PutObject with a correct ChecksumCRC32 succeeds and echoes the checksum

PutObject with a correct ChecksumSHA256 succeeds and echoes the checksum

UploadPart with ChecksumAlgorithm CRC32 but a CRC32C checksum header is rejected

The multipart upload and the part both declare CRC32, but the part carries an x-amz-checksum-crc32c value instead. The source test accepted InvalidRequest or InvalidArgument; both are HTTP 400.

UploadPart declaring a checksum algorithm different from the multipart upload's is rejected

The multipart upload was initialized with CRC32 but the part declares ChecksumAlgorithm SHA1. The source test accepted InvalidRequest or InvalidArgument; both are HTTP 400.

UploadPart with a checksum value of a different algorithm than the upload's is rejected

The multipart upload was initialized with CRC32 but the part carries an x-amz-checksum-sha256 value. The source test accepted InvalidRequest or InvalidArgument; both are HTTP 400.

UploadPartCopy succeeds when source and multipart upload use different checksum algorithms

The source object carries a SHA1 checksum while the multipart upload declares SHA256; the copy must succeed and return a CopyPartResult with an ETag. The source test skipped on InvalidArgument/NotImplemented (MinIO tolerance); on AWS the copy succeeds.

UploadPartCopy from a CRC32-checksummed source into a CRC32 multipart upload succeeds

Source object and multipart upload use the same checksum algorithm; the copy must succeed and return a CopyPartResult with an ETag. The source test skipped on NotImplemented/InvalidArgument (MinIO tolerance); on AWS the copy succeeds.

UploadPartCopy into a checksum-less multipart upload returns no checksums in CopyPartResult

The source object was uploaded with a SHA1 checksum but the multipart upload declares no checksum algorithm, so the CopyPartResult must not contain any checksum members.

UploadPart with two different checksum headers is rejected

The part carries both an x-amz-checksum-sha1 and an x-amz-checksum-crc32c value. The source test accepted InvalidRequest or InvalidArgument; both are HTTP 400.

UploadPart with ChecksumAlgorithm CRC32 succeeds and returns an ETag

UploadPart with ChecksumAlgorithm SHA1 succeeds and returns an ETag

UploadPart with ChecksumAlgorithm SHA256 succeeds and returns an ETag

GetObjectAttributes checksum matches PutObject checksum (CRC32)

One of four per-algorithm cases from the source loop.

GetObjectAttributes checksum matches PutObject checksum (CRC32C)

One of four per-algorithm cases from the source loop.

GetObjectAttributes checksum matches PutObject checksum (SHA1)

One of four per-algorithm cases from the source loop.

ListObjectsV2 lists all objects uploaded with checksum algorithms

Uploads four objects with CRC32/CRC32C/SHA1/SHA256 checksum algorithms and lists the bucket. The source test's per-entry ChecksumAlgorithm shape check was conditional on the field being present and is not asserted here.

PutObject of an empty body with ChecksumAlgorithm CRC32 returns a CRC32 checksum

One of four per-algorithm cases from the source loop; this iteration's body size is 200 * 0 = 0 bytes.

PutObject with ChecksumAlgorithm CRC32C returns a CRC32C checksum

One of four per-algorithm cases from the source loop.

PutObject with ChecksumAlgorithm SHA1 returns a SHA1 checksum

One of four per-algorithm cases from the source loop.

PutObject with ChecksumAlgorithm SHA256 returns a SHA256 checksum (600-byte body)

One of four per-algorithm cases from the source loop.

PutObject with ChecksumAlgorithm CRC32 returns a CRC32 checksum

The source test also asserted ChecksumType == FULL_OBJECT only when the field was present; that conditional check is omitted.

PutObject with an incorrect client-provided CRC32 checksum is rejected

AWS returns 400 BadDigest for an x-amz-checksum-crc32 mismatch. The source test also accepted InvalidRequest, InvalidDigest and XAmzContentChecksumMismatch from other implementations.

PutObject with a correct client-provided CRC32 checksum succeeds and echoes it

Multipart upload with CRC32 part checksums completes successfully

Multipart upload with SHA256 part checksums completes successfully

CopyObject across buckets preserves the source SHA256 checksum

CopyObject with MetadataDirective=COPY preserves the source checksum

CopyObject with ChecksumAlgorithm=CRC32 computes a CRC32 checksum for the destination

CopyObject with ChecksumAlgorithm=SHA256 computes a checksum for the destination

Source object has no checksum; copying with ChecksumAlgorithm=SHA256 returns the computed SHA256 in CopyObjectResult.

CopyObject with ChecksumAlgorithm=SHA1 computes a SHA1 checksum

CopyObject with ChecksumAlgorithm=SHA256 computes a SHA256 checksum

CopyObject preserves the source object's existing SHA256 checksum

CopyObject with ChecksumAlgorithm=SHA256 replaces the source's CRC32 checksum

CopyObject onto itself with MetadataDirective=REPLACE adds a SHA256 checksum

CreateMultipartUpload with ChecksumAlgorithm CRC32 echoes the algorithm

PutObject If-None-Match: * is evaluated against the current version on a versioned bucket

PutObject with non-matching If-Match ETag fails with PreconditionFailed and leaves object intact

PutObject with If-None-Match: * creates a nonexistent key

PutObject with If-None-Match: * on an existing key fails with PreconditionFailed and leaves object intact

Conditional DeleteObject with matching IfMatch ETag succeeds with 204

Conditional DeleteObject with a wrong IfMatch ETag returns PreconditionFailed

Original tolerated implementations that ignore IfMatch on DeleteObject (MinIO) or return InvalidArgument; AWS enforces the precondition.

PutObject with a non-matching If-Match returns 412 and leaves the object unchanged

GetObject with If-Unmodified-Since in the past returns 412 PreconditionFailed

The source used utcnow() minus one day; a fixed date guaranteed to precede any object creation preserves the semantics.

GetObject with non-matching If-Match ETag returns PreconditionFailed

GetObject with matching If-Match ETag returns the object

PutObject with non-matching If-Match returns PreconditionFailed

PutObject with If-Match matching the current ETag succeeds and returns a new ETag

CompleteMultipartUpload with non-matching If-Match returns PreconditionFailed

CompleteMultipartUpload with If-Match matching the existing object's ETag succeeds

CopyObject with a non-matching CopySourceIfMatch returns 412 PreconditionFailed

CopyObject with a matching CopySourceIfMatch copies the object

CopyObject with a past CopySourceIfModifiedSince copies the object

The source used now-1h; a fixed past date guaranteed to precede the object's LastModified preserves the semantics.

CopyObject with a matching CopySourceIfNoneMatch returns 412 PreconditionFailed

CopyObject with a past CopySourceIfUnmodifiedSince returns 412 PreconditionFailed

The source used now-1h; a fixed past date guaranteed to precede the object's LastModified preserves the semantics.

GetObject with a future If-Modified-Since is ignored and returns the object

The source used now+1h; a fixed far-future date guaranteed to postdate the object's LastModified preserves the semantics.

GetObject with a matching If-None-Match returns 304 Not Modified

The source accepted error code NotModified or the bare '304'.

HeadObject with a non-matching If-Match returns 412 PreconditionFailed

HeadObject with a matching If-Match returns the object metadata

HeadObject with a future If-Modified-Since is ignored and returns the object

The source used now+1h; a fixed far-future date guaranteed to postdate the object's LastModified preserves the semantics.

HeadObject with a matching If-None-Match returns 304 Not Modified

The source accepted error code NotModified or the bare '304'.

HeadObject with a future If-Unmodified-Since succeeds

The source used now+1h; a fixed far-future date guaranteed to postdate the object's LastModified preserves the semantics.

Conditional DeleteObject with If-Match rejects stale ETag, succeeds on match

DeleteObject with If-Match: * deletes an existing object

DeleteObjects with a per-key If-Match ETag precondition on an unversioned bucket

CopyObject with non-matching x-amz-copy-source-if-match returns PreconditionFailed

CopyObject with matching x-amz-copy-source-if-match succeeds

CopyObject with non-matching x-amz-copy-source-if-none-match succeeds

CopyObject with matching x-amz-copy-source-if-none-match returns PreconditionFailed

Copy a 16 MiB object within a bucket

Copy from a non-existent source bucket returns 404

Copy an object to a different bucket

Copy from another user's private object into own bucket is denied

Copy with REPLACE directive overwrites metadata and content type (3-byte object)

Copy retains metadata and content type (3-byte object)

Copy an object onto itself without changes returns InvalidRequest

Copy an object onto itself with the REPLACE metadata directive

Copy preserves the source object's Content-Type

Copy specific versions across versioned and non-versioned buckets

Copy a specific version of an object whose key needs URL encoding

Copy versions of a multipart object across versioned and non-versioned buckets, retaining body, metadata and content type

Copy a zero-length object

Checksums are preserved across overwrite and server-side copy

Reduced to the firm assertions of the source test: STANDARD upload ETag equals MD5, overwrite keeps content identical, and a server-side copy has identical content. Vendor-tolerant storage-class transition loops are omitted.

CopyObject to a new key within the same bucket succeeds

CopySource with a leading slash is accepted

CopyObject onto itself with an invalid MetadataDirective is rejected

Original test accepts InvalidArgument or InvalidRequest; both are HTTP 400, so only the status is asserted.

CopySource without a bucket/key slash separator is rejected

Original test accepts InvalidArgument, InvalidRequest, NoSuchKey or NoSuchBucket; AWS returns 400 InvalidArgument for a copy source lacking a slash, which is asserted here.

CopyObject with an invalid TaggingDirective is rejected

Original test accepts InvalidArgument or InvalidRequest; both are HTTP 400, so only the status is asserted.

CopyObject with MetadataDirective=COPY preserves metadata and Content-Type

CopyObject with MetadataDirective=REPLACE applies new metadata and Content-Type

CopyObject of a non-existent directory-style key returns NoSuchKey

CopyObject with MetadataDirective=REPLACE updates content headers

CopyObject with spaces in the source key

CopyObject with TaggingDirective=COPY preserves source tags

CopyObject with TaggingDirective=REPLACE applies new tags

CopyObject with a malformed x-amz-copy-source (no bucket/key separator) is rejected

The original test accepted InvalidArgument or InvalidRequest; AWS returns InvalidArgument for a copy source without a bucket/key separator. Expressed as a raw-HTTP step so the malformed header bypasses SDK client-side validation.

CopyObject to a non-existing destination bucket returns NoSuchBucket

CopyObject with a non-existing source key returns NoSuchKey

CopyObject preserves the source ContentType by default

CopyObject response includes a CopyObjectResult and the copy has an ETag

CopyObject with default tagging directive copies the source tags

CopyObject with TaggingDirective REPLACE replaces the source tags

CopyObject between buckets preserves ContentType and custom metadata

CopyObject preserves all content headers and custom metadata by default

The original test set Expires to a dynamic now+10h timestamp; a fixed future HTTP-date is used instead (Expires is not asserted here).

CopyObject onto itself with REPLACE sets the new metadata map

CopyObject preserves CacheControl and Expires headers

The original test set Expires to a dynamic now+24h timestamp; a fixed future HTTP-date is used instead, and only the presence of Expires is asserted (as in the original).

CopyObject preserves the CRC32 checksum of the source object

CopyObject tagging directives: default copies tags, REPLACE substitutes them

CopyObject with CopySourceIfMatch: matching ETag succeeds, wrong ETag fails

Original test accepted any error for the wrong-ETag copy (bare except); the canonical S3 behavior of 412 PreconditionFailed is asserted here.

CopyObject of a 6 MiB object preserves its size

Prefix rename via CopyObject + DeleteObject leaves old prefix empty and content intact

Directory rename emulated as copy-to-new-prefix then delete-from-old. Object count reduced from the source's 1000 to a representative sample.

CopyObject of an object over 5 GiB is rejected; UploadPartCopy in parts copies it

S3 copies at most 5 GiB in one CopyObject and directs larger objects to multipart copy. The source is one byte over the limit, so it is itself built as two parts (a single PUT is capped at 5 GiB). The single-request copy fails with InvalidRequest; the same object copies as two UploadPartCopy ranges. Tagged large: the run generates and uploads 5 GiB.

GetBucketCors on a bucket without CORS configuration returns NoSuchCORSConfiguration

GetBucketCors on a non-existent bucket returns NoSuchBucket

Keys containing URL-encoding-like characters round-trip literally

Keys that look percent-encoded or contain '+', '?' and '#' must be stored and retrieved literally, not decoded.

Path-traversal-like keys and Windows reserved names round-trip

Keys containing ../ or ..\ sequences must be stored literally (no path normalization); Windows reserved device names are ordinary keys.

Keys containing CR/LF and escape control characters round-trip

The original also tried a key containing a NUL (0x00) byte, accepting either success or InvalidArgument rejection; that case is omitted because the accept-or-reject disjunction is not expressible.

Key longer than 1024 bytes is rejected

The original accepted KeyTooLong* or InvalidRequest; AWS returns KeyTooLongError.

Unicode object key round-trip

Object key containing '+' is listable by literal '+' prefix and HEADable

The source test branches on an SDK capability flag for legacy '+'-as-space URL encoding; the correct S3 behavior (default branch) is that '+' in a key is a literal plus sign.

Real-world object keys mixing paths, dates, '@', parentheses, colons, '#' and brackets round-trip

Listing order assertion relies on S3's guaranteed ascending UTF-8 binary key order.

Path-like object keys (nested, leading/trailing/double slashes, directory markers) list correctly

Listing order assertion relies on S3's guaranteed ascending UTF-8 binary key order.

Object keys with 24 common special characters can be created, listed and read back

Listing order assertion relies on S3's guaranteed ascending UTF-8 binary key order.

Object keys with non-ASCII Unicode characters (CJK, accents, Cyrillic, emoji) list correctly

Listing order assertion relies on S3's guaranteed ascending UTF-8 binary key order.

Object keys requiring URL encoding round-trip through put, get and list

Keys with URL-special ASCII characters round-trip through PutObject/GetObject

Space, plus, percent, question mark, hash, ampersand, equals and at-sign in object keys. The original accepted InvalidArgument rejection as an alternative outcome for lenient vendors; AWS S3 accepts all of these keys, so the vector asserts the round-trip.

Path-separator variations in keys are stored as-is and listable by prefix

Double/triple slashes, leading slash, dot and dot-dot segments must not be normalized: each key appears verbatim in a prefix listing (prefixes are the first five characters of the key, as in the original test).

A raw space and a percent-encoded space are distinct object keys

'test space.txt' and 'test%20space.txt' are two different objects. The original also tolerated normalization to a single form; AWS S3 stores both distinctly, so the listing asserts exactly the two keys.

UTF-8 international keys round-trip through PutObject/GetObject

Accented Latin, Cyrillic, Chinese, Japanese and Korean keys. The original accepted InvalidArgument rejection as an alternative outcome; AWS S3 accepts any UTF-8 key, so the vector asserts the round-trip.

Spaces and percent sequences in directory and file parts are accepted

PutObject with reserved characters at different path positions, then ListObjectsV2 with the directory part as Prefix and '/' Delimiter. The original recorded the listing outcome without failing on absence, so the converted steps assert only that both operations succeed.

Query-string-like characters in keys are accepted and retrievable

Keys containing '?', '&', '=' and '#' sequences that resemble query strings or fragments must not be interpreted as such. The original accepted InvalidArgument rejection as an alternative outcome; AWS S3 accepts these keys.

Object keys are case-sensitive

GetObject with the case-swapped form of each stored key must fail. The original accepted any error; AWS S3 returns 404 NoSuchKey since the case-swapped key does not exist.

An 819-character key round-trips

A long key approaching URL length limits (within the 1024-byte S3 key limit). The original accepted KeyTooLong/RequestURITooLong as an alternative outcome; AWS S3 accepts keys up to 1024 bytes, so the vector asserts the round-trip.

CreateMultipartUpload preserves keys with non-ASCII (Greek, Chinese) characters

ListObjectsV2 KeyCount matches the number of keys in the bucket

ListObjects with letter delimiter groups keys into common prefixes

ListObjects with slash delimiter rolls keys up into common prefixes

ListObjects with dot delimiter groups keys into common prefixes

ListObjects with empty delimiter behaves as no delimiter and echoes none

ListObjects without a delimiter returns all keys and echoes no delimiter

ListObjects with percent delimiter groups keys into common prefixes

ListObjects delimiter and prefix pagination with Marker and NextMarker

ListObjects with prefix ending in the delimiter returns the exact-match key

ListObjects with newline delimiter matches no keys and returns all objects

ListObjects with whitespace delimiter groups keys into common prefixes

Objects in one bucket do not appear when listing a different bucket

ListObjects with url encoding-type URL-encodes keys and common prefixes

ListObjects paginates with MaxKeys and Marker

ListObjectsV2 with letter delimiter groups keys into common prefixes

ListObjectsV2 with slash delimiter rolls keys up into common prefixes and counts them in KeyCount

ListObjectsV2 with dot delimiter groups keys into common prefixes

ListObjectsV2 with empty delimiter behaves as no delimiter and echoes none

ListObjectsV2 without a delimiter returns all keys and echoes no delimiter