@scality/data-browser-library 1.0.0-preview.2

package/dist/test/msw/handlers/listObjectVersions.js

@@ -0,0 +1,83 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const listObjectVersionsHandler = rest.get(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (!url.searchParams.has("versions")) return;
+    const prefix = url.searchParams.get("prefix") || "";
+    const delimiter = url.searchParams.get("delimiter") || "";
+    const maxKeys = parseInt(url.searchParams.get("max-keys") || "1000", 10);
+    const keyMarker = url.searchParams.get("key-marker");
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if (bucketName.includes("access-denied-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        if (bucketName.includes("empty-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <ListVersionsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Name>${bucketName}</Name>
+              <Prefix>${prefix}</Prefix>
+              <Delimiter>${delimiter}</Delimiter>
+              <MaxKeys>${maxKeys}</MaxKeys>
+              <IsTruncated>false</IsTruncated>
+            </ListVersionsResult>`));
+        if (keyMarker) {
+            const pageKey = prefix && "file.txt" !== prefix ? `${prefix.replace(/\/$/, "")}-v3.txt` : "file-v3.txt";
+            return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <ListVersionsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Name>${bucketName}</Name>
+              <Prefix>${prefix}</Prefix>
+              <Delimiter>${delimiter}</Delimiter>
+              <MaxKeys>${maxKeys}</MaxKeys>
+              <IsTruncated>false</IsTruncated>
+              <Version>
+                <Key>${pageKey}</Key>
+                <VersionId>version-id-3</VersionId>
+                <IsLatest>true</IsLatest>
+                <LastModified>2023-10-12T17:50:00.000Z</LastModified>
+                <ETag>&quot;version-etag-3&quot;</ETag>
+                <Size>1024</Size>
+                <StorageClass>STANDARD</StorageClass>
+              </Version>
+            </ListVersionsResult>`));
+        }
+        const hasMorePages = bucketName.includes("paginated-bucket");
+        const baseKey = prefix && "file.txt" !== prefix ? prefix : "file.txt";
+        const deletedKey = prefix && "file.txt" !== prefix ? `${prefix.replace(/\/$/, "")}-deleted.txt` : "deleted-file.txt";
+        const nextKey = prefix && "file.txt" !== prefix ? `${prefix.replace(/\/$/, "")}-v2.txt` : "file-v2.txt";
+        return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+          <ListVersionsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+            <Name>${bucketName}</Name>
+            <Prefix>${prefix}</Prefix>
+            <Delimiter>${delimiter}</Delimiter>
+            <MaxKeys>${maxKeys}</MaxKeys>
+            <IsTruncated>${hasMorePages}</IsTruncated>
+            ${hasMorePages ? `<NextKeyMarker>${nextKey}</NextKeyMarker><NextVersionIdMarker>version-id-2</NextVersionIdMarker>` : ""}
+            <Version>
+              <Key>${baseKey}</Key>
+              <VersionId>version-id-1</VersionId>
+              <IsLatest>true</IsLatest>
+              <LastModified>2023-10-12T17:50:00.000Z</LastModified>
+              <ETag>&quot;version-etag-1&quot;</ETag>
+              <Size>1024</Size>
+              <StorageClass>STANDARD</StorageClass>
+            </Version>
+            <Version>
+              <Key>${baseKey}</Key>
+              <VersionId>version-id-2</VersionId>
+              <IsLatest>false</IsLatest>
+              <LastModified>2023-10-11T17:50:00.000Z</LastModified>
+              <ETag>&quot;version-etag-2&quot;</ETag>
+              <Size>512</Size>
+              <StorageClass>STANDARD</StorageClass>
+            </Version>
+            <DeleteMarker>
+              <Key>${deletedKey}</Key>
+              <VersionId>delete-marker-1</VersionId>
+              <IsLatest>true</IsLatest>
+              <LastModified>2023-10-10T17:50:00.000Z</LastModified>
+            </DeleteMarker>
+          </ListVersionsResult>`));
+    }
+    return res(ctx.status(200));
+});
+export { listObjectVersionsHandler };

package/dist/test/msw/handlers/listObjects.d.ts

@@ -0,0 +1 @@
+export declare const listObjectsHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

package/dist/test/msw/handlers/listObjects.js

@@ -0,0 +1,66 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const listObjectsHandler = rest.get(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if ("2" !== url.searchParams.get("list-type")) return;
+    const prefix = url.searchParams.get("prefix") || "";
+    const delimiter = url.searchParams.get("delimiter") || "";
+    const maxKeys = parseInt(url.searchParams.get("max-keys") || "1000", 10);
+    const continuationToken = url.searchParams.get("continuation-token");
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if (bucketName.includes("access-denied-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        if (bucketName.includes("empty-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Name>${bucketName}</Name>
+              <Prefix>${prefix}</Prefix>
+              <Delimiter>${delimiter}</Delimiter>
+              <MaxKeys>${maxKeys}</MaxKeys>
+              <IsTruncated>false</IsTruncated>
+            </ListBucketResult>`));
+        if (continuationToken) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Name>${bucketName}</Name>
+              <Prefix>${prefix}</Prefix>
+              <Delimiter>${delimiter}</Delimiter>
+              <MaxKeys>${maxKeys}</MaxKeys>
+              <IsTruncated>false</IsTruncated>
+              <Contents>
+                <Key>${prefix}file3.txt</Key>
+                <LastModified>2023-10-12T17:50:00.000Z</LastModified>
+                <ETag>&quot;d41d8cd98f00b204e9800998ecf8427e&quot;</ETag>
+                <Size>2048</Size>
+                <StorageClass>STANDARD</StorageClass>
+              </Contents>
+            </ListBucketResult>`));
+        const hasMorePages = bucketName.includes("paginated-bucket");
+        return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+          <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+            <Name>${bucketName}</Name>
+            <Prefix>${prefix}</Prefix>
+            <Delimiter>${delimiter}</Delimiter>
+            <MaxKeys>${maxKeys}</MaxKeys>
+            <IsTruncated>${hasMorePages}</IsTruncated>
+            ${hasMorePages ? "<NextContinuationToken>token-123</NextContinuationToken>" : ""}
+            <Contents>
+              <Key>${prefix}file1.txt</Key>
+              <LastModified>2023-10-12T17:50:00.000Z</LastModified>
+              <ETag>&quot;d41d8cd98f00b204e9800998ecf8427e&quot;</ETag>
+              <Size>1024</Size>
+              <StorageClass>STANDARD</StorageClass>
+            </Contents>
+            <Contents>
+              <Key>${prefix}file2.txt</Key>
+              <LastModified>2023-10-12T17:50:00.000Z</LastModified>
+              <ETag>&quot;e58ed763928cf52221fa5c4e2d6422a&quot;</ETag>
+              <Size>512</Size>
+              <StorageClass>STANDARD</StorageClass>
+            </Contents>
+            ${delimiter ? `<CommonPrefixes><Prefix>${prefix}folder1/</Prefix></CommonPrefixes>` : ""}
+          </ListBucketResult>`));
+    }
+    return res(ctx.status(200));
+});
+export { listObjectsHandler };

package/dist/test/msw/handlers/objectLegalHold.d.ts

@@ -0,0 +1 @@
+export declare const getObjectLegalHoldHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

package/dist/test/msw/handlers/objectLegalHold.js

@@ -0,0 +1,24 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+import { ObjectLockLegalHoldStatus } from "@aws-sdk/client-s3";
+const getObjectLegalHoldHandler = rest.get(`${getS3BaseUrl()}/:bucketName/*`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    const objectKey = url.pathname.substring(url.pathname.indexOf("/", 1) + 1);
+    if (!url.searchParams.has("legal-hold")) return;
+    if ("string" == typeof bucketName) {
+        if ("no-such-bucket" === bucketName || "non-existent-bucket" === bucketName) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if ("access-denied-bucket" === bucketName || "restricted-bucket" === bucketName) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied", bucketName, objectKey)));
+        if ("network-error-bucket" === bucketName) return res.networkError("Failed to connect");
+        if ("non-existent-object.txt" === objectKey) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchKey", "The specified key does not exist.", bucketName, objectKey)));
+        if ("no-legal-hold-object.txt" === objectKey) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchObjectLockConfiguration", "The specified object does not have a ObjectLock configuration", bucketName, objectKey)));
+        let status = ObjectLockLegalHoldStatus.ON;
+        if ("legal-hold-off-object.txt" === objectKey) status = ObjectLockLegalHoldStatus.OFF;
+        return res(ctx.status(200), ctx.set("Content-Type", "application/xml"), ctx.body(`<?xml version="1.0" encoding="UTF-8"?>
+          <LegalHold xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+            <Status>${status}</Status>
+          </LegalHold>`));
+    }
+    return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidArgument", "Invalid request parameters")));
+});
+export { getObjectLegalHoldHandler };

package/dist/test/msw/handlers/objectRetention.d.ts

@@ -0,0 +1 @@
+export declare const getObjectRetentionHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

package/dist/test/msw/handlers/objectRetention.js

@@ -0,0 +1,27 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const getObjectRetentionHandler = rest.get(`${getS3BaseUrl()}/:bucketName/*`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    const objectKey = url.pathname.substring(url.pathname.indexOf("/", 1) + 1);
+    if (!url.searchParams.has("retention")) return;
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if (objectKey.includes("non-existent-object")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchKey", "The specified key does not exist.", bucketName, objectKey)));
+        if (bucketName.includes("restricted-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (objectKey.includes("no-retention-object")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchObjectLockConfiguration", "The specified object does not have a ObjectLock configuration", bucketName, objectKey)));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        if (objectKey.includes("compliance-retention")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <Retention xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Mode>COMPLIANCE</Mode>
+              <RetainUntilDate>2024-12-31T23:59:59.000Z</RetainUntilDate>
+            </Retention>`));
+        return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+          <Retention xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+            <Mode>GOVERNANCE</Mode>
+            <RetainUntilDate>2024-06-30T23:59:59.000Z</RetainUntilDate>
+          </Retention>`));
+    }
+    return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidArgument", "Invalid request parameters")));
+});
+export { getObjectRetentionHandler };

package/dist/test/msw/handlers/putBucketAcl.d.ts

@@ -0,0 +1 @@
+export declare const putBucketAclHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

package/dist/test/msw/handlers/putBucketAcl.js

@@ -0,0 +1,18 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const putBucketAclHandler = rest.put(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (!url.searchParams.has("acl")) return;
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if (bucketName.includes("access-denied-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (bucketName.includes("invalid-acl-bucket")) return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidRequest", "The ACL configuration is invalid")));
+        if (bucketName.includes("malformed-acl-bucket")) return res(ctx.status(400), ctx.xml(createS3ErrorXml("MalformedACLError", "The XML provided does not match the expected format")));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        const aclParam = url.searchParams.get("acl");
+        if ("invalid-acl-type" === aclParam) return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidArgument", "Invalid canned ACL value")));
+    }
+    return res(ctx.status(200), ctx.set("Content-Type", "application/xml"), ctx.body(""));
+});
+export { putBucketAclHandler };

package/dist/test/msw/handlers/putObject.d.ts

@@ -0,0 +1 @@
+export declare const putObjectHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

package/dist/test/msw/handlers/putObject.js

@@ -0,0 +1,16 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const putObjectHandler = rest.put(`${getS3BaseUrl()}/:bucketName/*`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    const objectKey = url.pathname.substring(url.pathname.indexOf("/", 1) + 1);
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("non-existent-bucket")) return res(ctx.status(404), ctx.xml(createS3ErrorXml("NoSuchBucket", "The specified bucket does not exist", bucketName)));
+        if (bucketName.includes("access-denied-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        if (objectKey.includes("invalid-key")) return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidRequest", "The specified key is not valid")));
+        return res(ctx.status(200), ctx.set("ETag", '"mock-etag-123"'), ctx.set("x-amz-version-id", "mock-version-id"), ctx.set("x-amz-server-side-encryption", "AES256"), ctx.body(""));
+    }
+    return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidArgument", "Invalid request parameters")));
+});
+export { putObjectHandler };

package/dist/test/msw/handlers.d.ts

@@ -0,0 +1,4 @@
+export declare const createBucketHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;
+export declare const getBucketVersioningHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;
+export declare const s3Handlers: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>[];
+export default s3Handlers;

package/dist/test/msw/handlers.js

@@ -0,0 +1,109 @@
+import { rest } from "msw";
+import { listBucketsHandler } from "./handlers/listBuckets.js";
+import { deleteBucketHandler } from "./handlers/deleteBucket.js";
+import { getBucketLocationHandler } from "./handlers/getBucketLocation.js";
+import { getBucketAclHandler } from "./handlers/getBucketAcl.js";
+import { getBucketPolicyHandler } from "./handlers/getBucketPolicy.js";
+import { listObjectsHandler } from "./handlers/listObjects.js";
+import { listObjectVersionsHandler } from "./handlers/listObjectVersions.js";
+import { headObjectHandler } from "./handlers/headObject.js";
+import { getObjectRetentionHandler } from "./handlers/objectRetention.js";
+import { getObjectLegalHoldHandler } from "./handlers/objectLegalHold.js";
+import { putObjectHandler } from "./handlers/putObject.js";
+import { putBucketAclHandler } from "./handlers/putBucketAcl.js";
+import { createS3ErrorXml, getS3BaseUrl } from "./utils.js";
+const isBucketConfigurationRequest = (url)=>{
+    const configParams = [
+        "acl",
+        "policy",
+        "versioning",
+        "lifecycle",
+        "cors",
+        "website",
+        "tagging",
+        "encryption",
+        "notification",
+        "replication",
+        "requestPayment",
+        "accelerate",
+        "metrics",
+        "inventory",
+        "analytics",
+        "intelligentTiering",
+        "ownershipControls",
+        "publicAccessBlock",
+        "logging",
+        "location"
+    ];
+    return configParams.some((param)=>url.searchParams.has(param));
+};
+const createBucketHandler = rest.put(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (isBucketConfigurationRequest(url)) return;
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("existing-bucket")) return res(ctx.status(409), ctx.xml(createS3ErrorXml("BucketAlreadyExists", "The requested bucket name is not available", bucketName)));
+        if (bucketName.includes("restricted-bucket")) return res(ctx.status(403), ctx.xml(createS3ErrorXml("AccessDenied", "Access Denied")));
+        if (bucketName.includes("invalid-bucket-name")) return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidBucketName", "Invalid bucket name")));
+        if (bucketName.includes("network-test-bucket")) return res.networkError("Network connection failed");
+    }
+    return res(ctx.status(200), ctx.set("Location", `/${bucketName}`), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+        <CreateBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <Location>/${bucketName}</Location>
+        </CreateBucketResult>`));
+});
+const getBucketVersioningHandler = rest.get(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (!url.searchParams.has("versioning")) return;
+    if ("string" == typeof bucketName) {
+        if (bucketName.includes("nonexistent-bucket")) return res(ctx.status(404), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <Error>
+              <Code>NoSuchBucket</Code>
+              <Message>The specified bucket does not exist</Message>
+              <BucketName>${bucketName}</BucketName>
+            </Error>`));
+        if (bucketName.includes("access-denied-bucket")) return res(ctx.status(403), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <Error>
+              <Code>AccessDenied</Code>
+              <Message>Access Denied</Message>
+            </Error>`));
+        if (bucketName.includes("network-error-bucket")) return res.networkError("Network connection failed");
+        if (bucketName.includes("enabled-versioning-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Status>Enabled</Status>
+              <MfaDelete>Disabled</MfaDelete>
+            </VersioningConfiguration>`));
+        if (bucketName.includes("suspended-versioning-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Status>Suspended</Status>
+              <MfaDelete>Disabled</MfaDelete>
+            </VersioningConfiguration>`));
+        if (bucketName.includes("mfa-enabled-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Status>Enabled</Status>
+              <MfaDelete>Enabled</MfaDelete>
+            </VersioningConfiguration>`));
+    }
+    return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+        <VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+        </VersioningConfiguration>`));
+});
+const s3Handlers = [
+    listBucketsHandler,
+    createBucketHandler,
+    deleteBucketHandler,
+    getBucketVersioningHandler,
+    getBucketLocationHandler,
+    getBucketAclHandler,
+    getBucketPolicyHandler,
+    listObjectsHandler,
+    listObjectVersionsHandler,
+    getObjectRetentionHandler,
+    getObjectLegalHoldHandler,
+    putObjectHandler,
+    headObjectHandler,
+    putBucketAclHandler
+];
+const handlers = s3Handlers;
+export { createBucketHandler, handlers as default, getBucketVersioningHandler, s3Handlers };

package/dist/test/msw/index.d.ts

@@ -0,0 +1,2 @@
+export { server, setupMswServer, overrideHandlers } from "./server";
+export { s3Handlers, createBucketHandler, getBucketVersioningHandler, } from "./handlers";

package/dist/test/msw/index.js

@@ -0,0 +1,3 @@
+import { overrideHandlers, server, setupMswServer } from "./server.js";
+import { createBucketHandler, getBucketVersioningHandler, s3Handlers } from "./handlers.js";
+export { createBucketHandler, getBucketVersioningHandler, overrideHandlers, s3Handlers, server, setupMswServer };

package/dist/test/msw/server.d.ts

@@ -0,0 +1,4 @@
+export declare const server: import("msw/node").SetupServerApi;
+export declare const setupMswServer: () => void;
+export declare const overrideHandlers: (...handlers: Parameters<typeof server.use>) => void;
+export { s3Handlers } from "./handlers";

package/dist/test/msw/server.js

@@ -0,0 +1,20 @@
+import { setupServer } from "msw/node";
+import { s3Handlers } from "./handlers.js";
+const server = setupServer(...s3Handlers);
+const setupMswServer = ()=>{
+    beforeAll(()=>{
+        server.listen({
+            onUnhandledRequest: "warn"
+        });
+    });
+    afterEach(()=>{
+        server.resetHandlers();
+    });
+    afterAll(()=>{
+        server.close();
+    });
+};
+const overrideHandlers = (...handlers)=>{
+    server.use(...handlers);
+};
+export { overrideHandlers, s3Handlers, server, setupMswServer };

package/dist/test/msw/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getS3BaseUrl: () => string;
+export declare const createS3ErrorXml: (code: string, message: string, bucketName?: string, key?: string) => string;

package/dist/test/msw/utils.js

@@ -0,0 +1,13 @@
+const getS3BaseUrl = ()=>"https://s3.amazonaws.com";
+const createS3ErrorXml = (code, message, bucketName, key)=>{
+    let resourceDetails = "";
+    if (bucketName) resourceDetails += `<BucketName>${bucketName}</BucketName>`;
+    if (key) resourceDetails += `<Key>${key}</Key>`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+    <Error>
+      <Code>${code}</Code>
+      <Message>${message}</Message>
+      ${resourceDetails}
+    </Error>`;
+};
+export { createS3ErrorXml, getS3BaseUrl };

package/dist/test/setup.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/dist/test/setup.js

@@ -0,0 +1,82 @@
+import "@testing-library/jest-dom";
+import { TextDecoder, TextEncoder } from "util";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
+process.env.AWS_ACCESS_KEY_ID = "test-access-key";
+process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";
+process.env.AWS_DEFAULT_REGION = "us-east-1";
+const testS3Config = {
+    endpoint: "http://localhost:8000",
+    region: "us-east-1",
+    realHost: "s3.amazonaws.com",
+    forcePathStyle: true
+};
+const testDevConfig = {
+    useProxy: false,
+    proxyEndpoint: "http://localhost:3000/api/s3",
+    proxyBasePath: "/api/s3",
+    proxyHost: "localhost",
+    proxyPort: 3000
+};
+globalThis.__S3_CONFIG__ = testS3Config;
+globalThis.__DEV_CONFIG__ = testDevConfig;
+globalThis.__IS_DEVELOPMENT__ = true;
+globalThis.__IS_PRODUCTION__ = false;
+jest.setTimeout(10000);
+Object.assign(__webpack_require__.g, {
+    TextDecoder: TextDecoder,
+    TextEncoder: TextEncoder
+});
+Object.defineProperty(HTMLCanvasElement.prototype, "getContext", {
+    value: ()=>null
+});
+jest.mock("pretty-bytes", ()=>({
+        __esModule: true,
+        default: (bytes)=>{
+            const sizes = [
+                "B",
+                "KB",
+                "MB",
+                "GB"
+            ];
+            let i = 0;
+            let num = bytes;
+            while(num >= 1024 && i < sizes.length - 1){
+                num /= 1024;
+                i++;
+            }
+            return `${Math.round(num)} ${sizes[i]}`;
+        }
+    }));
+if (!File.prototype.arrayBuffer) File.prototype.arrayBuffer = function() {
+    return new Promise((resolve)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>resolve(reader.result);
+        reader.readAsArrayBuffer(this);
+    });
+};
+const originalError = console.error;
+const originalWarn = console.warn;
+beforeAll(()=>{
+    console.error = (...args)=>{
+        if ("string" == typeof args[0] && (args[0].includes("AWS") || args[0].includes("S3") || args[0].includes("Warning: An update to") || args[0].includes('Warning: A props object containing a "key" prop'))) return;
+        originalError(...args);
+    };
+    console.warn = (...args)=>{
+        if ("string" == typeof args[0] && (args[0].includes("AWS") || args[0].includes("S3") || args[0].includes("Warning: An update to") || args[0].includes('Warning: A props object containing a "key" prop'))) return;
+        originalWarn(...args);
+    };
+});
+afterAll(()=>{
+    console.error = originalError;
+    console.warn = originalWarn;
+});

package/dist/test/testUtils.d.ts

@@ -0,0 +1,82 @@
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+import React from "react";
+import { S3BrowserConfig, S3Credentials } from "../types";
+export declare const testConfig: S3BrowserConfig;
+export declare const testCredentials: S3Credentials;
+export declare const mockS3Client: {
+    send: jest.Mock<any, any, any>;
+};
+export declare const MockedS3Client: jest.MockedClass<typeof S3Client>;
+export declare const MockedPutObjectCommand: jest.MockedClass<typeof PutObjectCommand>;
+export declare function mockOffsetSize(width: number, height: number): void;
+/**
+ * Creates a simple QueryClient wrapper for tests that don't need DataBrowser context
+ */
+export declare const createQueryWrapper: () => ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Creates a test wrapper with DataBrowser context and QueryClient
+ */
+export declare const createTestWrapper: (config?: S3BrowserConfig, credentials?: S3Credentials) => ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Renders a hook with the standard test wrapper
+ */
+export declare const renderHookWithWrapper: <TProps, TResult>(hook: (props: TProps) => TResult, options?: {
+    initialProps?: TProps;
+    config?: S3BrowserConfig;
+    credentials?: S3Credentials;
+}) => import("@testing-library/react").RenderHookResult<TResult, TProps>;
+/**
+ * Creates a test File object
+ */
+export declare const createTestFile: (name: string, content: string, type?: string) => File;
+/**
+ * Sets up S3 mocks for testing
+ */
+export declare const setupS3Mocks: () => void;
+/**
+ * Common mock setup that should be run before each test
+ */
+export declare const setupCommonMocks: () => void;
+/**
+ * Configuration test utilities for overriding build-time globals
+ */
+import type { S3Configuration, DevelopmentConfiguration } from "../config/types";
+type GlobalConfigOverrides = {
+    s3?: Partial<S3Configuration>;
+    dev?: Partial<DevelopmentConfiguration>;
+    environment?: {
+        isDevelopment?: boolean;
+        isProduction?: boolean;
+    };
+};
+/**
+ * Override global configuration for testing specific scenarios
+ * Useful for testing different deployment environments or proxy configurations
+ */
+export declare const overrideGlobalConfig: (overrides: GlobalConfigOverrides) => void;
+/**
+ * Reset global configuration to test defaults
+ * Should be called in afterEach or afterAll to ensure test isolation
+ */
+export declare const resetGlobalConfig: () => void;
+/**
+ * Test helper for running tests with specific global configuration
+ */
+export declare const withGlobalConfig: (overrides: GlobalConfigOverrides, testFn: () => void | Promise<void>) => () => Promise<void>;
+/**
+ * Validates that a hook follows the expected factory pattern
+ */
+export declare const validateFactoryHook: (hook: any, operationName: string) => void;
+/**
+ * Creates a factory test error
+ */
+export declare const createFactoryTestError: (testContext: string, operationName: string, details?: string) => Error;
+/**
+ * Validates that a hook result has expected React Query properties
+ */
+export declare const validateHookResult: (result: any, hookType: "query" | "mutation" | "infiniteQuery") => void;
+export { setupMswServer, overrideHandlers } from "./msw";