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

package/dist/schemas/bucketPolicySchema.json

@@ -0,0 +1,321 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "AWS S3 Bucket Policy",
+  "description": "JSON Schema for AWS S3 Bucket Policy documents",
+  "type": "object",
+  "required": ["Version", "Statement"],
+  "properties": {
+    "Version": {
+      "type": "string",
+      "enum": ["2012-10-17", "2008-10-17"],
+      "description": "The policy language version. Use '2012-10-17' for current policies."
+    },
+    "Id": {
+      "type": "string",
+      "description": "Optional identifier for the policy"
+    },
+    "Statement": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["Effect"],
+        "oneOf": [
+          { "required": ["Principal"] },
+          { "required": ["NotPrincipal"] }
+        ],
+        "properties": {
+          "Sid": {
+            "type": "string",
+            "pattern": "^[a-zA-Z0-9]+$",
+            "description": "Optional statement ID for identifying the statement (alphanumeric only)"
+          },
+          "Effect": {
+            "type": "string",
+            "enum": ["Allow", "Deny"],
+            "description": "Whether to allow or deny the actions"
+          },
+          "Principal": {
+            "oneOf": [
+              {
+                "type": "string",
+                "enum": ["*"],
+                "description": "All principals (public access)"
+              },
+              {
+                "type": "object",
+                "description": "Specific principals",
+                "minProperties": 1,
+                "properties": {
+                  "AWS": {
+                    "oneOf": [
+                      {
+                        "type": "string",
+                        "description": "AWS account, IAM user, or role ARN"
+                      },
+                      {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": { "type": "string" },
+                        "description": "List of AWS accounts, IAM users, or role ARNs"
+                      }
+                    ]
+                  },
+                  "Service": {
+                    "oneOf": [
+                      {
+                        "type": "string",
+                        "description": "AWS service principal (e.g., 's3.amazonaws.com')"
+                      },
+                      {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": { "type": "string" },
+                        "description": "List of AWS service principals"
+                      }
+                    ]
+                  },
+                  "Federated": {
+                    "oneOf": [
+                      {
+                        "type": "string",
+                        "description": "Federated identity provider ARN"
+                      },
+                      {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": { "type": "string" },
+                        "description": "List of federated identity provider ARNs"
+                      }
+                    ]
+                  },
+                  "CanonicalUser": {
+                    "oneOf": [
+                      {
+                        "type": "string",
+                        "description": "Canonical user ID"
+                      },
+                      {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": { "type": "string" },
+                        "description": "List of canonical user IDs"
+                      }
+                    ]
+                  }
+                },
+                "additionalProperties": false
+              }
+            ],
+            "description": "The principal that is allowed or denied access"
+          },
+          "NotPrincipal": {
+            "type": "object",
+            "description": "All principals EXCEPT those specified",
+            "minProperties": 1,
+            "properties": {
+              "AWS": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "description": "AWS account, IAM user, or role ARN"
+                  },
+                  {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "type": "string" },
+                    "description": "List of AWS accounts, IAM users, or role ARNs"
+                  }
+                ]
+              },
+              "Service": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "description": "AWS service principal (e.g., 's3.amazonaws.com')"
+                  },
+                  {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "type": "string" },
+                    "description": "List of AWS service principals"
+                  }
+                ]
+              },
+              "Federated": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "description": "Federated identity provider ARN"
+                  },
+                  {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "type": "string" },
+                    "description": "List of federated identity provider ARNs"
+                  }
+                ]
+              },
+              "CanonicalUser": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "description": "Canonical user ID"
+                  },
+                  {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "type": "string" },
+                    "description": "List of canonical user IDs"
+                  }
+                ]
+              }
+            },
+            "additionalProperties": false
+          },
+          "Action": {
+            "oneOf": [
+              {
+                "type": "string",
+                "description": "Single action or action with wildcards (e.g., 's3:GetObject', 's3:*')"
+              },
+              {
+                "type": "array",
+                "minItems": 1,
+                "items": { "type": "string" },
+                "description": "List of actions"
+              }
+            ],
+            "description": "The actions that are allowed or denied"
+          },
+          "NotAction": {
+            "oneOf": [
+              {
+                "type": "string",
+                "description": "Single action to exclude"
+              },
+              {
+                "type": "array",
+                "minItems": 1,
+                "items": { "type": "string" },
+                "description": "List of actions to exclude"
+              }
+            ],
+            "description": "All actions EXCEPT those specified"
+          },
+          "Resource": {
+            "oneOf": [
+              {
+                "type": "string",
+                "description": "Single resource ARN (e.g., 'arn:aws:s3:::bucket/*')"
+              },
+              {
+                "type": "array",
+                "minItems": 1,
+                "items": { "type": "string" },
+                "description": "List of resource ARNs"
+              }
+            ],
+            "description": "The resources to which the actions apply"
+          },
+          "NotResource": {
+            "oneOf": [
+              {
+                "type": "string",
+                "description": "Single resource ARN to exclude"
+              },
+              {
+                "type": "array",
+                "minItems": 1,
+                "items": { "type": "string" },
+                "description": "List of resource ARNs to exclude"
+              }
+            ],
+            "description": "All resources EXCEPT those specified"
+          },
+          "Condition": {
+            "type": "object",
+            "description": "Optional conditions for when the policy is in effect",
+            "properties": {
+              "StringEquals": { "$ref": "#/$defs/conditionBlock" },
+              "StringNotEquals": { "$ref": "#/$defs/conditionBlock" },
+              "StringEqualsIgnoreCase": { "$ref": "#/$defs/conditionBlock" },
+              "StringNotEqualsIgnoreCase": { "$ref": "#/$defs/conditionBlock" },
+              "StringLike": { "$ref": "#/$defs/conditionBlock" },
+              "StringNotLike": { "$ref": "#/$defs/conditionBlock" },
+              "NumericEquals": { "$ref": "#/$defs/conditionBlock" },
+              "NumericNotEquals": { "$ref": "#/$defs/conditionBlock" },
+              "NumericLessThan": { "$ref": "#/$defs/conditionBlock" },
+              "NumericLessThanEquals": { "$ref": "#/$defs/conditionBlock" },
+              "NumericGreaterThan": { "$ref": "#/$defs/conditionBlock" },
+              "NumericGreaterThanEquals": { "$ref": "#/$defs/conditionBlock" },
+              "DateEquals": { "$ref": "#/$defs/conditionBlock" },
+              "DateNotEquals": { "$ref": "#/$defs/conditionBlock" },
+              "DateLessThan": { "$ref": "#/$defs/conditionBlock" },
+              "DateLessThanEquals": { "$ref": "#/$defs/conditionBlock" },
+              "DateGreaterThan": { "$ref": "#/$defs/conditionBlock" },
+              "DateGreaterThanEquals": { "$ref": "#/$defs/conditionBlock" },
+              "Bool": { "$ref": "#/$defs/conditionBlock" },
+              "BinaryEquals": { "$ref": "#/$defs/conditionBlock" },
+              "IpAddress": { "$ref": "#/$defs/conditionBlock" },
+              "NotIpAddress": { "$ref": "#/$defs/conditionBlock" },
+              "ArnEquals": { "$ref": "#/$defs/conditionBlock" },
+              "ArnNotEquals": { "$ref": "#/$defs/conditionBlock" },
+              "ArnLike": { "$ref": "#/$defs/conditionBlock" },
+              "ArnNotLike": { "$ref": "#/$defs/conditionBlock" },
+              "Null": { "$ref": "#/$defs/conditionBlock" }
+            },
+            "additionalProperties": {
+              "$ref": "#/$defs/conditionBlock"
+            }
+          }
+        },
+        "additionalProperties": false,
+        "allOf": [
+          {
+            "oneOf": [{ "required": ["Action"] }, { "required": ["NotAction"] }]
+          },
+          {
+            "oneOf": [
+              { "required": ["Resource"] },
+              { "required": ["NotResource"] }
+            ]
+          }
+        ]
+      }
+    }
+  },
+  "$defs": {
+    "conditionBlock": {
+      "type": "object",
+      "description": "Key-value pairs for condition evaluation",
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "type": "string",
+            "description": "Single condition value"
+          },
+          {
+            "type": "number",
+            "description": "Numeric condition value"
+          },
+          {
+            "type": "boolean",
+            "description": "Boolean condition value"
+          },
+          {
+            "type": "array",
+            "items": {
+              "oneOf": [
+                { "type": "string" },
+                { "type": "number" },
+                { "type": "boolean" }
+              ]
+            },
+            "description": "Multiple condition values"
+          }
+        ]
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,14 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const deleteBucketHandler = rest["delete"](`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    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("bucket-not-empty")) return res(ctx.status(409), ctx.xml(createS3ErrorXml("BucketNotEmpty", "The bucket you tried to delete is not empty", bucketName)));
+        if (bucketName.includes("restricted-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("error-callback-bucket")) return res(ctx.status(500), ctx.xml(createS3ErrorXml("InternalError", "We encountered an internal error. Please try again.")));
+    }
+    return res(ctx.status(204));
+});
+export { deleteBucketHandler };

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

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

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

@@ -0,0 +1,96 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const getBucketAclHandler = rest.get(`${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("network-error-bucket")) return res.networkError("Failed to connect");
+        if (bucketName.includes("private-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Owner>
+                <ID>owner-canonical-id-123</ID>
+                <DisplayName>bucket-owner</DisplayName>
+              </Owner>
+              <AccessControlList>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                    <ID>owner-canonical-id-123</ID>
+                    <DisplayName>bucket-owner</DisplayName>
+                  </Grantee>
+                  <Permission>FULL_CONTROL</Permission>
+                </Grant>
+              </AccessControlList>
+            </AccessControlPolicy>`));
+        if (bucketName.includes("public-read-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Owner>
+                <ID>owner-canonical-id-123</ID>
+                <DisplayName>bucket-owner</DisplayName>
+              </Owner>
+              <AccessControlList>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                    <ID>owner-canonical-id-123</ID>
+                    <DisplayName>bucket-owner</DisplayName>
+                  </Grantee>
+                  <Permission>FULL_CONTROL</Permission>
+                </Grant>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Group">
+                    <URI>http://acs.amazonaws.com/groups/global/AllUsers</URI>
+                  </Grantee>
+                  <Permission>READ</Permission>
+                </Grant>
+              </AccessControlList>
+            </AccessControlPolicy>`));
+        if (bucketName.includes("shared-bucket")) return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+            <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+              <Owner>
+                <ID>owner-canonical-id-123</ID>
+                <DisplayName>bucket-owner</DisplayName>
+              </Owner>
+              <AccessControlList>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                    <ID>owner-canonical-id-123</ID>
+                    <DisplayName>bucket-owner</DisplayName>
+                  </Grantee>
+                  <Permission>FULL_CONTROL</Permission>
+                </Grant>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                    <ID>user-canonical-id-456</ID>
+                    <DisplayName>shared-user</DisplayName>
+                  </Grantee>
+                  <Permission>READ_WRITE</Permission>
+                </Grant>
+                <Grant>
+                  <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Group">
+                    <URI>http://acs.amazonaws.com/groups/global/AuthenticatedUsers</URI>
+                  </Grantee>
+                  <Permission>READ</Permission>
+                </Grant>
+              </AccessControlList>
+            </AccessControlPolicy>`));
+    }
+    return res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+        <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <Owner>
+            <ID>owner-canonical-id-123</ID>
+            <DisplayName>bucket-owner</DisplayName>
+          </Owner>
+          <AccessControlList>
+            <Grant>
+              <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                <ID>owner-canonical-id-123</ID>
+                <DisplayName>bucket-owner</DisplayName>
+              </Grantee>
+              <Permission>FULL_CONTROL</Permission>
+            </Grant>
+          </AccessControlList>
+        </AccessControlPolicy>`));
+});
+export { getBucketAclHandler };

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

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

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

@@ -0,0 +1,23 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const getBucketLocationHandler = rest.get(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (!url.searchParams.has("location")) 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("network-error-bucket")) return res.networkError("Failed to connect");
+        let locationConstraint = null;
+        if (bucketName.includes("eu-west-1")) locationConstraint = "eu-west-1";
+        else if (bucketName.includes("ap-southeast-1")) locationConstraint = "ap-southeast-1";
+        else if (bucketName.includes("us-west-2")) locationConstraint = "us-west-2";
+        const response = locationConstraint ? `<?xml version="1.0" encoding="UTF-8"?>
+           <LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/">${locationConstraint}</LocationConstraint>` : `<?xml version="1.0" encoding="UTF-8"?>
+           <LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"></LocationConstraint>`;
+        return res(ctx.status(200), ctx.set("Content-Type", "application/xml"), ctx.body(response));
+    }
+    return res(ctx.status(200), ctx.set("Content-Type", "application/xml"), ctx.body(`<?xml version="1.0" encoding="UTF-8"?>
+        <LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"></LocationConstraint>`));
+});
+export { getBucketLocationHandler };

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

@@ -0,0 +1,11 @@
+/**
+ * MSW handler for S3 GetBucketPolicy requests
+ *
+ * Simulates different bucket policy scenarios based on bucket naming patterns:
+ * - Buckets starting with "policy-" return sample policies
+ * - "no-policy-bucket" returns NoSuchBucketPolicy error
+ * - "access-denied-bucket" returns AccessDenied error
+ * - "invalid-json-bucket" returns malformed JSON for testing
+ * - Other buckets return a default allow-all policy
+ */
+export declare const getBucketPolicyHandler: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultRequestBody>>;

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

@@ -0,0 +1,72 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const getBucketPolicyHandler = rest.get(`${getS3BaseUrl()}/:bucketName`, (req, res, ctx)=>{
+    const { bucketName } = req.params;
+    const url = new URL(req.url);
+    if (!url.searchParams.has("policy")) return;
+    if ("no-policy-bucket" === bucketName) return res(ctx.status(404), ctx.set("Content-Type", "application/xml"), ctx.body(createS3ErrorXml("NoSuchBucketPolicy", "The bucket policy does not exist", bucketName)));
+    if ("access-denied-bucket" === bucketName) return res(ctx.status(403), ctx.set("Content-Type", "application/xml"), ctx.body(createS3ErrorXml("AccessDenied", "Access Denied", bucketName)));
+    if ("invalid-json-bucket" === bucketName) return res(ctx.status(200), ctx.set("Content-Type", "application/json"), ctx.body('{"Version": "2012-10-17", "Statement": [invalid json}'));
+    let policy;
+    policy = "string" == typeof bucketName && bucketName.startsWith("policy-readonly-") ? {
+        Version: "2012-10-17",
+        Statement: [
+            {
+                Sid: "PublicReadGetObject",
+                Effect: "Allow",
+                Principal: "*",
+                Action: "s3:GetObject",
+                Resource: `arn:aws:s3:::${bucketName}/*`
+            }
+        ]
+    } : "string" == typeof bucketName && bucketName.startsWith("policy-complex-") ? {
+        Version: "2012-10-17",
+        Statement: [
+            {
+                Sid: "AllowSpecificUser",
+                Effect: "Allow",
+                Principal: {
+                    AWS: "arn:aws:iam::123456789012:user/ExampleUser"
+                },
+                Action: [
+                    "s3:GetObject",
+                    "s3:PutObject"
+                ],
+                Resource: `arn:aws:s3:::${bucketName}/*`
+            },
+            {
+                Sid: "DenyInsecureConnections",
+                Effect: "Deny",
+                Principal: "*",
+                Action: "s3:*",
+                Resource: [
+                    `arn:aws:s3:::${bucketName}`,
+                    `arn:aws:s3:::${bucketName}/*`
+                ],
+                Condition: {
+                    Bool: {
+                        "aws:SecureTransport": "false"
+                    }
+                }
+            }
+        ]
+    } : {
+        Version: "2012-10-17",
+        Statement: [
+            {
+                Sid: "DefaultStatement",
+                Effect: "Allow",
+                Principal: {
+                    AWS: "arn:aws:iam::123456789012:root"
+                },
+                Action: "s3:*",
+                Resource: [
+                    `arn:aws:s3:::${bucketName}`,
+                    `arn:aws:s3:::${bucketName}/*`
+                ]
+            }
+        ]
+    };
+    return res(ctx.status(200), ctx.set("Content-Type", "application/json"), ctx.body(JSON.stringify(policy)));
+});
+export { getBucketPolicyHandler };

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

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

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

@@ -0,0 +1,17 @@
+import { rest } from "msw";
+import { createS3ErrorXml, getS3BaseUrl } from "../utils.js";
+const headObjectHandler = rest.head(`${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);
+    const versionId = url.searchParams.get("versionId");
+    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("NotFound", "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 (bucketName.includes("network-error-bucket")) return res.networkError("Failed to connect");
+        return res(ctx.status(200), ctx.set("x-amz-meta-custom-key", "custom-value"), ctx.set("Content-Length", "12345"), ctx.set("Content-Type", "application/octet-stream"), ctx.set("ETag", '"some-etag"'), ctx.set("Last-Modified", new Date().toUTCString()), ctx.set("x-amz-version-id", versionId || "some-version-id"));
+    }
+    return res(ctx.status(400), ctx.xml(createS3ErrorXml("InvalidArgument", "Invalid request parameters")));
+});
+export { headObjectHandler };

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

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

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

@@ -0,0 +1,24 @@
+import { rest } from "msw";
+import { getS3BaseUrl } from "../utils.js";
+const listBucketsHandler = rest.get(`${getS3BaseUrl()}/`, (_req, res, ctx)=>res(ctx.status(200), ctx.xml(`<?xml version="1.0" encoding="UTF-8"?>
+        <ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <Owner>
+            <ID>owner-id-123</ID>
+            <DisplayName>Test Owner</DisplayName>
+          </Owner>
+          <Buckets>
+            <Bucket>
+              <Name>bucket-1</Name>
+              <CreationDate>2023-10-12T17:50:00.000Z</CreationDate>
+            </Bucket>
+            <Bucket>
+              <Name>bucket-2</Name>
+              <CreationDate>2023-10-11T17:50:00.000Z</CreationDate>
+            </Bucket>
+            <Bucket>
+              <Name>bucket-3</Name>
+              <CreationDate>2023-10-10T17:50:00.000Z</CreationDate>
+            </Bucket>
+          </Buckets>
+        </ListAllMyBucketsResult>`)));
+export { listBucketsHandler };

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

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