@tomassabol/aws-services 1.8.0 → 1.8.2

package/test/s3.test.ts

@@ -1,78 +0,0 @@
-/* eslint-disable  @typescript-eslint/no-explicit-any */
-import { mockClient } from "aws-sdk-client-mock"
-import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3"
-import { Readable } from "stream"
-import { sdkStreamMixin } from "@aws-sdk/util-stream-node"
-import { client, getObjectFromS3, putObjectToS3 } from "../src/s3"
-
-const s3Mock = mockClient(client)
-
-describe("S3", () => {
-  describe("putObjectToS3()", () => {
-    test("should put object to S3", async () => {
-      s3Mock.on(PutObjectCommand).resolves({
-        ETag: "etag",
-      })
-
-      const params = {
-        bucket: "bucket",
-        key: "key",
-        body: "body",
-        contentEncoding: "content-encoding",
-        contentType: "content-type",
-      }
-
-      await expect(putObjectToS3(params)).resolves.toEqual({ ETag: "etag" })
-    })
-
-    test("should fail when put object to S3 fails", async () => {
-      s3Mock.on(PutObjectCommand).rejects(new Error("fail"))
-
-      await expect(putObjectToS3({} as any)).rejects.toThrowError("fail")
-    })
-  })
-
-  describe("getObjectFromS3()", () => {
-    test("should get object from S3", async () => {
-      s3Mock.on(GetObjectCommand).resolves({
-        ETag: "etag",
-        Body: sdkStreamMixin(Readable.from("object")),
-      })
-
-      const params = {
-        bucket: "bucket",
-        key: "key",
-      }
-
-      const data = (await getObjectFromS3(params)) as any
-
-      expect(data).toMatchInlineSnapshot(`
-        Uint8Array [
-          111,
-          98,
-          106,
-          101,
-          99,
-          116,
-        ]
-      `)
-    })
-
-    test("should fail when get object body is undefined", async () => {
-      s3Mock.on(GetObjectCommand).resolves({
-        ETag: "etag",
-        Body: undefined,
-      })
-
-      await expect(getObjectFromS3({} as any)).rejects.toThrowError(
-        "Body not found"
-      )
-    })
-
-    test("should fail when get object from S3 fails", async () => {
-      s3Mock.on(GetObjectCommand).rejects(new Error("fail"))
-
-      await expect(getObjectFromS3({} as any)).rejects.toThrowError("fail")
-    })
-  })
-})

package/test/secrets-manager.test.ts

@@ -1,55 +0,0 @@
-import { mockClient } from "aws-sdk-client-mock"
-import { GetSecretValueCommand } from "@aws-sdk/client-secrets-manager"
-import { client, getSecret, getSecretAsObject } from "../src/secrets-manager"
-
-const secretsManagerMock = mockClient(client)
-
-describe("secrets-manager", () => {
-  describe("getSecret()", () => {
-    test("should retrieve secret string", async () => {
-      secretsManagerMock.on(GetSecretValueCommand).resolves({
-        SecretString: "secret-string",
-      })
-
-      await expect(getSecret("secret-name")).resolves.toBe("secret-string")
-    })
-
-    test("should fail when string empty", async () => {
-      secretsManagerMock.on(GetSecretValueCommand).resolves({
-        SecretString: "",
-      })
-
-      await expect(getSecret("secret-name")).rejects.toThrow(
-        "SecretString value not found"
-      )
-    })
-
-    test("should fail", async () => {
-      secretsManagerMock.on(GetSecretValueCommand).rejects(new Error("fail"))
-
-      await expect(getSecret("secret-name")).rejects.toThrowError("fail")
-    })
-  })
-
-  describe("getSecretAsObject()", () => {
-    test("should return secret object", async () => {
-      secretsManagerMock.on(GetSecretValueCommand).resolves({
-        SecretString: JSON.stringify({ foo: "bar" }),
-      })
-
-      await expect(getSecretAsObject("secret-name")).resolves.toEqual({
-        foo: "bar",
-      })
-    })
-
-    test("should fail when invalid object", async () => {
-      secretsManagerMock.on(GetSecretValueCommand).resolves({
-        SecretString: "invalid-object",
-      })
-
-      await expect(getSecretAsObject("secret-name")).rejects.toThrowError(
-        "Cannot parse secret secret-name. Expected JSON."
-      )
-    })
-  })
-})

package/test/sns.test.ts

@@ -1,59 +0,0 @@
-import { SNSClient, PublishCommand } from "@aws-sdk/client-sns"
-import { publishMessageToSNS, snsClient } from "../src/sns"
-
-jest.mock("@aws-sdk/client-sns", () => {
-  return {
-    SNSClient: jest.fn(() => {
-      return {
-        send: jest.fn(),
-      }
-    }),
-    PublishCommand: jest.fn(),
-  }
-})
-
-describe("SNS", () => {
-  beforeEach(() => {
-    ;(SNSClient as jest.Mock).mockClear()
-    ;(PublishCommand as unknown as jest.Mock).mockClear()
-    ;(snsClient.send as jest.Mock).mockClear()
-  })
-
-  it("should create instance of SNSClient", () => {
-    expect(snsClient).toBeDefined()
-  })
-
-  it("should call publishSNSMessage successfully", async () => {
-    const sendMock = jest.fn()
-    ;(snsClient.send as jest.Mock) = sendMock
-
-    const params = {
-      topicArn: "arn:aws:sns:eu-central-1:123456789012:MyTopic",
-      message: "Test message",
-    }
-
-    await publishMessageToSNS(params)
-    expect(sendMock).toBeCalledTimes(1)
-    expect(PublishCommand).toHaveBeenCalledWith({
-      TopicArn: params.topicArn,
-      Message: params.message,
-    })
-  })
-
-  it("should throw an error if publishSNSMessage fails", async () => {
-    const sendMock = jest
-      .fn()
-      .mockRejectedValue(new Error("Failed to send message"))
-    ;(snsClient.send as jest.Mock) = sendMock
-
-    const params = {
-      topicArn: "arn:aws:sns:euj-central-1:123456789012:MyTopic",
-      message: "Test message",
-    }
-
-    await expect(publishMessageToSNS(params)).rejects.toThrow(
-      "Failed to send message"
-    )
-    expect(sendMock).toBeCalledTimes(1)
-  })
-})

package/test/sqs.test.ts

@@ -1,46 +0,0 @@
-import { mockClient } from "aws-sdk-client-mock"
-import { SendMessageCommand } from "@aws-sdk/client-sqs"
-import { client, sendSqsMessage } from "../src/sqs"
-
-const sqsMock = mockClient(client)
-
-describe("sqs", () => {
-  describe("sendSqsMessage()", () => {
-    test("should send string as message to SQS", async () => {
-      sqsMock.on(SendMessageCommand).resolves({
-        MessageId: "message-id",
-      })
-
-      const params = {
-        queueUrl: "queue-url",
-        message: "message",
-      }
-
-      await expect(sendSqsMessage(params)).resolves.toBe("message-id")
-    })
-
-    test("should send stringified object as message to SQS", async () => {
-      sqsMock.on(SendMessageCommand).resolves({
-        MessageId: "message-id",
-      })
-
-      const params = {
-        queueUrl: "queue-url",
-        message: { foo: "bar" },
-      }
-
-      await expect(sendSqsMessage(params)).resolves.toBe("message-id")
-    })
-
-    test("should fail", async () => {
-      sqsMock.on(SendMessageCommand).rejects(new Error("fail"))
-
-      const params = {
-        queueUrl: "queue-url",
-        message: "message",
-      }
-
-      await expect(sendSqsMessage(params)).rejects.toThrowError("fail")
-    })
-  })
-})

package/test/ssm.test.ts

@@ -1,85 +0,0 @@
-/* eslint-disable  @typescript-eslint/no-explicit-any */
-import { mockClient } from "aws-sdk-client-mock"
-import { GetParametersCommand } from "@aws-sdk/client-ssm"
-import { client, getSsmParameters } from "../src/ssm"
-
-const ssmMock = mockClient(client)
-
-describe("ssm", () => {
-  describe("getSsmParameters()", () => {
-    test("should return paramaters", async () => {
-      ssmMock.on(GetParametersCommand).resolves({
-        Parameters: [
-          { Name: "/my-params/foo", Value: "bar" },
-          { Name: "/my-params/baz", Value: "qux" },
-        ],
-      })
-
-      const params = {
-        foo: "/my-params/foo",
-        baz: "/my-params/baz",
-      }
-
-      await expect(getSsmParameters(params)).resolves.toEqual({
-        foo: "bar",
-        baz: "qux",
-      })
-    })
-
-    test("should fail when SSM parameter name is not string", async () => {
-      ssmMock.on(GetParametersCommand).resolves({
-        Parameters: [{ Name: 42 as any, Value: "bar" }],
-      })
-
-      const params = {
-        foo: "/my-params/foo",
-      }
-
-      await expect(getSsmParameters(params)).rejects.toThrow(
-        "Received invalid SSM parameter 42"
-      )
-    })
-
-    test("should fail when SSM parameter does not contain Parameters", async () => {
-      ssmMock.on(GetParametersCommand).resolves({})
-
-      const params = {
-        foo: "/my-params/foo",
-      }
-
-      await expect(getSsmParameters(params)).rejects.toThrow(
-        "Cannot obtain SSM parameters: foo"
-      )
-    })
-
-    test("should fail when SSM parameter value is not string", async () => {
-      ssmMock.on(GetParametersCommand).resolves({
-        Parameters: [{ Name: "/my-params/foo", Value: 42 as any }],
-      })
-
-      const params = {
-        foo: "/my-params/foo",
-      }
-
-      await expect(getSsmParameters(params)).rejects.toThrow(
-        "Received invalid value of SSM parameter /my-params/foo"
-      )
-    })
-
-    test("should fail when not all parameters are found", async () => {
-      ssmMock.on(GetParametersCommand).resolves({
-        Parameters: [{ Name: "/my-params/foo", Value: "bar" }],
-      })
-
-      const params = {
-        foo: "/my-params/foo",
-        baz: "/my-params/baz",
-        quux: "/my-params/quux",
-      }
-
-      await expect(getSsmParameters(params)).rejects.toThrow(
-        "Cannot obtain SSM parameters: baz, quux"
-      )
-    })
-  })
-})

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig",
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@tsconfig/node18",
-  "compilerOptions": {
-    "strict": true,
-    "declaration": true,
-    "outDir": "dist"
-  },
-  "include": ["src", "test"]
-}

package/typedoc.json

@@ -1,4 +0,0 @@
-{
-  "entryPoints": ["src/index.ts"],
-  "readme": "none"
-}