bucketManager.spec.cjs

const test = require("node:test");
const assert = require("node:assert/strict");
const { BucketManager } = require("../dist/index.js");

const TEST_PREFIX = Date.now();

test("create bucket", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `create-bucket-test-pass`
  const bucketNameToCreate = `${TEST_PREFIX}-create-bucket-test-pass`;
  await bucketManager.create(bucketNameToCreate);

  try {
    // List buckets
    const currentBuckets = await bucketManager.list(),
      createdBucket = currentBuckets.find((currentBucket) => {
        return currentBucket.Name === bucketNameToCreate;
      });

    // Assert new bucket exists
    assert.equal(createdBucket.Name, bucketNameToCreate);
  } finally {
    // Delete new bucket
    await bucketManager.delete(bucketNameToCreate);
  }
});

test("generate bucket cid", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `create-bucket-test-pass`
  const bucketNameToGenerate = `${TEST_PREFIX}-generate-bucket-test-pass`;
  await bucketManager.create(bucketNameToGenerate);

  try {
    // Generate bucket CID
    const generatedCid = await bucketManager.generateCid(bucketNameToGenerate);

    // Assert new bucket exists
    assert.equal(generatedCid, "bafybeiczsscdsbs7ffqz55asqdf3smv6klcw3gofszvwlyarci47bgf354");
  } finally {
    // Delete new bucket
    await bucketManager.delete(bucketNameToGenerate);
  }
});

test("list bucket cid", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `create-bucket-test-pass`
  const bucketNameToGenerate = `${TEST_PREFIX}-list-bucket-cid-test-pass`;
  await bucketManager.create(bucketNameToGenerate);

  try {
    // Generate bucket CID
    const generatedCid = await bucketManager.generateCid(bucketNameToGenerate);

    // Assert new bucket exists
    assert.equal(generatedCid, "bafybeiczsscdsbs7ffqz55asqdf3smv6klcw3gofszvwlyarci47bgf354");

    // List buckets
    const bucketsList = await bucketManager.list(),
      listedBucket = bucketsList.find((element) => {
        return element.Name === bucketNameToGenerate;
      }),
      listedBucketCid = await listedBucket.CID()

    // Assert listed CID
    assert.equal(listedBucketCid, "bafybeiczsscdsbs7ffqz55asqdf3smv6klcw3gofszvwlyarci47bgf354");
  } finally {
    // Delete new bucket
    await bucketManager.delete(bucketNameToGenerate);
  }
});

test("list bucket without cid", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `create-bucket-test-pass`
  const bucketNameToGenerate = `${TEST_PREFIX}-list-bucket-without-cid-test-pass`;
  await bucketManager.create(bucketNameToGenerate);

  try {
    // List buckets
    const bucketsList = await bucketManager.list(),
      listedBucket = bucketsList.find((element) => {
        return element.Name === bucketNameToGenerate;
      }),
      listedBucketCid = await listedBucket.CID()

    // Assert listed CID
    assert.equal(listedBucketCid, undefined);
  } finally {
    // Delete new bucket
    await bucketManager.delete(bucketNameToGenerate);
  }
});

test("list buckets", async () => {
  const testBucketName = `${TEST_PREFIX}-list-bucket-test-pass`,
    bucketManager = new BucketManager(
      process.env.TEST_S3_KEY || process.env.TEST_KEY,
      process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
    ),
    initialBucketsList = await bucketManager.list(),
    countToCreate = 3;
  for (let i = 0; i < countToCreate; i++) {
    await bucketManager.create(`${testBucketName}-${i}`);
  }
  const bucketsList = await bucketManager.list();
  for (let i = 0; i < countToCreate; i++) {
    await bucketManager.delete(`${testBucketName}-${i}`);
  }
  assert.strictEqual(
    bucketsList.length,
    initialBucketsList.length + countToCreate,
  );
});

test("delete bucket", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `delete-bucket-test-pass`
  const bucketNameToCreate = `${TEST_PREFIX}-delete-bucket-test-pass`;
  await bucketManager.create(bucketNameToCreate);

  // List buckets and assert new bucket exists
  const currentBuckets = await bucketManager.list(),
    createdBucket = currentBuckets.find((currentBucket) => {
      return currentBucket.Name === bucketNameToCreate;
    });
  if (typeof createdBucket === "undefined") {
    throw new Error(`Unable to create test bucket [delete-bucket-test-pass]`);
  }

  // Delete new bucket
  await bucketManager.delete(bucketNameToCreate);

  // List buckets and assert new bucket does not exist
  const updatedBuckets = await bucketManager.list(),
    deletedBucket = updatedBuckets.find((updatedBucket) => {
      return updatedBucket.Name === bucketNameToCreate;
    });
  assert.equal(typeof deletedBucket, "undefined");
});

test("set bucket privacy to public", async () => {
  // Initialize BucketManager
  const bucketManager = new BucketManager(
    process.env.TEST_S3_KEY || process.env.TEST_KEY,
    process.env.TEST_S3_SECRET || process.env.TEST_SECRET,
  );

  // Create bucket `toggle-bucket-test-pass`
  const bucketNameToCreate = `${TEST_PREFIX}-toggle-bucket-test-pass`;
  await bucketManager.create(bucketNameToCreate);

  try {
    // List buckets
    const currentBuckets = await bucketManager.list(),
      createdBucket = currentBuckets.find((currentBucket) => {
        return currentBucket.Name === bucketNameToCreate;
      });

    // Check Privacy
    const initialPrivacy = await bucketManager.getPrivacy(bucketNameToCreate);
    if (initialPrivacy === false) {
      throw new Error(`Unexpected Privacy State on Bucket`);
    }

    // Toggle Privacy
    await bucketManager.setPrivacy(bucketNameToCreate, false);

    // Check Privacy
    const updatedPrivacy = await bucketManager.getPrivacy(bucketNameToCreate);
    if (updatedPrivacy === true) {
      throw new Error(`Unexpected Privacy State on Bucket`);
    }

    // Assert new bucket exists
    assert.equal(createdBucket.Name, bucketNameToCreate);
  } finally {
    // Delete new bucket
    await bucketManager.delete(bucketNameToCreate);
  }
});