@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/tests/Config/Config.test.ts

@@ -0,0 +1,193 @@
+import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
+import { mockClient } from "aws-sdk-client-mock"
+import { expect } from "chai"
+
+import Configuration from "../../src/Config/Configuration"
+import { SampleConfig, SampleConfigSchema } from "../Test.utils"
+
+const SSMMock = mockClient(SSMClient)
+const config = new Configuration<SampleConfigSchema>(SampleConfig, "my-prefix")
+describe(`Optional remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config["resetCache"]()
+  })
+
+  test("Does not accept sync get", async () => {
+    let err = null
+    try {
+      // @ts-ignore
+      config.get("TOKEN_SECRET")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Optional value with null value", async () => {
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: undefined,
+      },
+    })
+    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    expect(token).is.undefined
+  })
+
+  test("Optional value with empty response", async () => {
+    SSMMock.on(GetParameterCommand).resolves({})
+    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    expect(token).is.undefined
+  })
+
+  test("Optional value with valid response", async () => {
+    const value = "abc"
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    expect(token).is.not.undefined
+    expect(token).to.be.equals(value)
+  })
+
+  test("Optional value rejection", async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
+    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    expect(token).is.undefined
+  })
+})
+
+describe(`Required remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config["resetCache"]()
+  })
+
+  test("Does not accept sync get", async () => {
+    let err = null
+    try {
+      // @ts-ignore
+      config.get("TOKEN_SECRET")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Required value with null value", async () => {
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: undefined,
+      },
+    })
+    let err = null
+    try {
+      await config.asyncGet("TOKEN_SECRET")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Required value with empty response", async () => {
+    SSMMock.on(GetParameterCommand).resolves({})
+    let err = null
+    try {
+      await config.asyncGet("TOKEN_SECRET")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Required value with valid response", async () => {
+    const value = "abc"
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const token = await config.asyncGet("TOKEN_SECRET")
+    expect(token).is.not.undefined
+    expect(token).to.be.equals(value)
+  })
+
+  test("Required value rejection", async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
+    let err = null
+    try {
+      await config.asyncGet("TOKEN_SECRET")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+})
+
+describe(`Optional local environment`, () => {
+  beforeEach(() => {
+    config["resetCache"]()
+  })
+
+  test("Optional value with null value", async () => {
+    const token = config.get("PATH123")
+    expect(token).is.undefined
+  })
+})
+
+describe(`Required local environment`, () => {
+  beforeEach(() => {
+    config["resetCache"]()
+  })
+
+  test("Required value with null value", async () => {
+    let err = null
+    try {
+      config.get("PATH_FALSY")
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Required value with valid response", async () => {
+    const key = "PATH"
+    const v = config.get(key)
+    expect(v).is.not.null
+    expect(v).to.be.equals(process.env[key])
+  })
+})
+
+describe(`Caching test`, () => {
+  test("Does cache previous fetched value", async () => {
+    const value = "123"
+    const key = "TOKEN_SECRET"
+    // initial fetch
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const v = await config.asyncGet(key)
+    expect(v).is.not.null
+    expect(v).to.be.equals(value)
+    // subsequent fetch
+    SSMMock.reset()
+    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
+    const v2 = await config.asyncGet(key)
+    expect(v2).is.not.null
+    expect(v2).to.be.equals(value)
+  })
+})
+
+export {}

package/tests/Config/EnvironmentVar.test.ts

@@ -0,0 +1,223 @@
+import {
+  SecretsManagerClient,
+  GetSecretValueCommand,
+} from "@aws-sdk/client-secrets-manager"
+import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
+import { mockClient } from "aws-sdk-client-mock"
+import { expect } from "chai"
+
+import EnvironmentVar, {
+  EnvironmentType,
+} from "../../src/Config/EnvironmentVar"
+
+const SSMMock = mockClient(SSMClient)
+const SecretsManagerMock = mockClient(SecretsManagerClient)
+
+function testRemoteEnv(mock, type, command) {
+  describe(`Optional ${type} environment`, () => {
+    // reset mock
+    beforeEach(() => {
+      mock.reset()
+    })
+
+    test("Does not accept sync resolve", async () => {
+      mock.on(command).resolves({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar("abc", type, true)
+        env.syncResolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.["message"]).is.not.null
+    })
+
+    test("Optional value with null value", async () => {
+      mock.on(command).resolves({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      const env = new EnvironmentVar("abc", type, true)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+
+    test("Optional value with empty response", async () => {
+      mock.on(command).resolves({})
+      const env = new EnvironmentVar("abc", type, true)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+
+    test("Optional value with valid response", async () => {
+      const value = "abc"
+      mock.on(command).resolves({
+        Parameter: {
+          Value: value,
+        },
+      })
+      const env = new EnvironmentVar(value, type, true)
+      const token = await env.resolve()
+      expect(token).is.not.undefined
+      expect(token).to.be.equals(value)
+    })
+
+    test("Optional value rejection", async () => {
+      const value = "abc"
+      mock.on(command).rejects(new Error("failed!"))
+      const env = new EnvironmentVar(value, type, true)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+  })
+
+  describe(`Required ${type} environment`, () => {
+    // reset mock
+    beforeEach(() => {
+      mock.reset()
+    })
+
+    test("Does not accept sync resolve", async () => {
+      mock.on(command).resolves({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar("abc", type)
+        env.syncResolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.["message"]).is.not.null
+    })
+
+    test("Required fails when null", async () => {
+      mock.on(command).resolves({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar("abc", type)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      console.log(err)
+      expect(err).is.not.null
+      expect(err?.["message"]).is.not.null
+    })
+
+    test("Required fails when empty response", async () => {
+      mock.on(command).resolves({})
+      let err = null
+      try {
+        const env = new EnvironmentVar("abc", type)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.["message"]).is.not.null
+    })
+
+    test("Required value with valid response", async () => {
+      const value = "abc"
+      mock.on(command).resolves({
+        Parameter: {
+          Value: value,
+        },
+      })
+      const env = new EnvironmentVar(value, type)
+      const token = await env.resolve()
+      expect(token).is.not.undefined
+      expect(token).to.be.equals(value)
+    })
+
+    test("Required value rejection", async () => {
+      mock.on(command).rejects(new Error("failed!"))
+      let err = null
+      try {
+        const env = new EnvironmentVar("abc", type)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.["message"]).is.not.null
+    })
+  })
+}
+
+/* Remote envs test */
+testRemoteEnv(SSMMock, EnvironmentType.PlainRemote, GetParameterCommand)
+testRemoteEnv(
+  SecretsManagerMock,
+  EnvironmentType.SecureRemote,
+  GetSecretValueCommand,
+)
+
+describe("Optional Local environment", () => {
+  test("Does accept async resolve", async () => {
+    const env = new EnvironmentVar("PATH123", EnvironmentType.Local, true)
+    const v = await env.resolve()
+    expect(v).is.undefined
+  })
+
+  test("Optional value with null value", async () => {
+    const env = new EnvironmentVar("PATH123", EnvironmentType.Local, true)
+    const token = env.syncResolve()
+    expect(token).is.undefined
+  })
+
+  test("Optional value with valid value", async () => {
+    const key = "PATH"
+    const env = new EnvironmentVar(key, EnvironmentType.Local, true)
+    const token = env.syncResolve()
+    expect(token).is.not.undefined
+    expect(token).to.be.equals(process.env[key])
+  })
+})
+
+describe("Required local environment", () => {
+  test("Does accept async resolve", async () => {
+    const key = "PATH"
+    const env = new EnvironmentVar(key, EnvironmentType.Local)
+    const v = await env.resolve()
+    expect(v).is.not.null
+    expect(v).to.be.equals(process.env[key])
+  })
+
+  test("Required fails when null", async () => {
+    let err = null
+    try {
+      const env = new EnvironmentVar("PATH123", EnvironmentType.Local)
+      env.syncResolve()
+    } catch (e) {
+      err = e
+    }
+    console.log(err)
+    expect(err).is.not.null
+    expect(err?.["message"]).is.not.null
+  })
+
+  test("Required value with valid value", async () => {
+    const key = "PATH"
+    const env = new EnvironmentVar(key, EnvironmentType.Local)
+    const v = env.syncResolve()
+    expect(v).is.not.null
+    expect(v).to.be.equals(process.env[key])
+  })
+})
+
+export {}

package/tests/Crypto/Crypto.test.ts

@@ -0,0 +1,90 @@
+import { DecryptCommand, EncryptCommand, KMSClient } from "@aws-sdk/client-kms"
+import { mockClient } from "aws-sdk-client-mock"
+import { expect } from "chai"
+
+import Crypto from "../../src/Crypto/Crypto"
+
+const KMSMock = mockClient(KMSClient)
+
+function fakeEncryption(v) {
+  const f = new TextEncoder().encode(v)
+  return Buffer.from(f as any, "utf8").toString("hex")
+}
+function fakeDecryption(v) {
+  return new TextEncoder().encode(v)
+}
+
+describe("Encryption", () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto("ca-central-1", "abc123")
+  test("Encrypts json object", async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.encryptData(encryptionObj)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(JSON.stringify(encryptionObj)))
+  })
+
+  test("Encrypts string", async () => {
+    const encryptionText = "Hello encryption!"
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(encryptionText),
+    })
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(encryptionText))
+  })
+
+  test("Fails to encrypt a number", async () => {
+    const encryptionText = 123
+    KMSMock.on(EncryptCommand).rejects(new Error("failed"))
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+describe("Decryption", () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto("ca-central-1", "abc123")
+  test("Decrypts json object", async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.decryptData(
+      fakeEncryption(JSON.stringify(encryptionObj)),
+    )
+    expect(token).is.not.null
+    expect(token).to.be.equals(JSON.stringify(encryptionObj))
+  })
+
+  test("Decrypts string", async () => {
+    const encryptionText = "abc123"
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(encryptionText),
+    })
+    const token = await provider.decryptData(fakeEncryption(encryptionText))
+    expect(token).is.not.null
+    expect(token).to.be.equals(encryptionText)
+  })
+
+  test("Fails to decrypt a number", async () => {
+    const encryptionText = 123
+    KMSMock.on(DecryptCommand).rejects(new Error("failed"))
+    // @ts-ignore
+    const token = await provider.decryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+export {}

package/tests/Crypto/JWT.test.ts

@@ -0,0 +1,92 @@
+import { expect } from "chai"
+
+import JWT from "../../src/Crypto/JWT"
+import { foreignToken, privateKey } from "../Test.utils"
+
+describe("Creates token", () => {
+  const provider = new JWT(privateKey, "7d")
+  test("Creates token without explicity expiration", () => {
+    const token = provider.createToken({ userID: 123 })
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+  })
+
+  test("Creates token with explicity expiration", () => {
+    const token = provider.createToken({ userID: 123 }, "7d")
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+  })
+
+  test("Creates token with explicity token override", () => {
+    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+  })
+
+  test("Creates token with explicity token options", () => {
+    const token = provider.createToken({ userID: 123 }, undefined, undefined, {
+      expiresIn: "7d",
+    })
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+  })
+
+  test("Creates token with no expiration", () => {
+    const localProvider = new JWT(privateKey)
+    const token = localProvider.createToken({ userID: 123 })
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+  })
+})
+
+describe("Validates token", () => {
+  const provider = new JWT(privateKey, "7d")
+  test("Succeed to validate just created token", () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
+    expect(token).to.be.a("string")
+    expect(token).is.not.null
+    // Validates token
+    const validationResp = provider.validateToken(token)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.true
+    expect(validationResp["isExpired"]).is.undefined
+    expect(validationResp["decodedToken"]).is.not.null
+    expect(validationResp["decodedToken"].userID).to.be.equals(123)
+    expect(validationResp["decodedToken"].exp).to.be.a("number")
+    expect(validationResp["decodedToken"].exp).to.be.above(Date.now() / 1000)
+  })
+
+  test("Fails to validate invalid token", () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
+    // Validates token
+    const validationResp = provider.validateToken(token + "123")
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp["isExpired"]).is.undefined
+    expect(validationResp["decodedToken"]).to.undefined
+  })
+
+  test("Fails to validate expired token", () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, "-7d", privateKey)
+    // Validates token
+    const validationResp = provider.validateToken(token)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp["isExpired"]).is.true
+    expect(validationResp["decodedToken"]).to.undefined
+  })
+
+  test("Fails to validate foreign token", () => {
+    // Validates token
+    const validationResp = provider.validateToken(foreignToken)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp["isExpired"]).is.undefined
+    expect(validationResp["decodedToken"]).to.undefined
+  })
+})
+
+export {}

package/tests/Logger/Logger.test.ts

@@ -0,0 +1,108 @@
+// get console ref and mock before logger import
+const consoleProxy = console
+const mock = jest.spyOn(consoleProxy, "log")
+// import logger after first ref
+import Logger from "../../src/Logger/Logger"
+// get console reference after logger import
+const transactionID = "123-456"
+
+function setContainerFlag(isContainer: boolean) {
+  if (isContainer) {
+    process.env["HYBRIDLESS_RUNTIME"] = "true"
+  } else {
+    process.env["HYBRIDLESS_RUNTIME"] = undefined
+  }
+}
+
+function fixLogTypePrefix(logType: string) {
+  if (logType == "exception") return "error"
+  if (logType == "warning") return "warn"
+  if (logType == "log") return "info"
+  return logType
+}
+
+function testLogs(isContainer: boolean, provider?: Logger) {
+  const type = isContainer ? "container" : "serverless"
+  const loggerType = !provider ? "Console" : "Logger"
+  const localProvider = provider || console
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log("TEST", { password: "123" })
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining(
+        (isContainer ? `${transactionID} ` : "") + "[INFO] [Logger.test.ts:",
+      ),
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining("] TEST **SUPPRESSED_SENSITIVE_DATA**"),
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (array)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log("TEST2", [{ password: "123" }])
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining(
+        (isContainer ? `${transactionID} ` : "") + "[INFO] [Logger.test.ts:",
+      ),
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining("] TEST2 **SUPPRESSED_SENSITIVE_DATA**"),
+    )
+  })
+
+  for (const logType of [
+    "log",
+    "debug",
+    "info",
+    "warn",
+    "warning",
+    "error",
+    "exception",
+  ]) {
+    test(`${type} - ${loggerType} ${logType}`, async () => {
+      setContainerFlag(isContainer)
+      localProvider[logType](logType.toUpperCase())
+      // alias
+      const logTypePrefix = fixLogTypePrefix(logType)
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(
+          (isContainer ? `${transactionID} ` : "") +
+            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`,
+        ),
+      )
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(`] ${logType.toUpperCase()}`),
+      )
+    })
+  }
+}
+
+describe("Logger", () => {
+  beforeEach(() => {
+    mock.mockClear()
+  })
+  const provider = new Logger(
+    {
+      logLevel: "DEBUG",
+      sensitiveFilteringKeywords: true,
+    },
+    transactionID,
+  )
+  provider.notGlobalLogger()
+  // Test serverless logs
+  testLogs(false, provider)
+  testLogs(false)
+  // Test container logs
+  testLogs(true, provider)
+  testLogs(true)
+})
+
+export {}