@creator.co/wapi 1.2.2 → 1.2.4

package/tests/API/Request.test.ts

@@ -1,184 +1,180 @@
-import { APIGatewayEvent, Context } from "aws-lambda"
-import { expect } from "chai"
+import { APIGatewayEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
 
-import Request from "../../src/API/Request"
-import Logger from "../../src/Logger/Logger"
+import Request from '../../src/API/Request'
+import Logger from '../../src/Logger/Logger'
 
 function newReq(event: any, context?: any) {
   const logger = new Logger(
     {
-      logLevel: "DEBUG",
+      logLevel: 'DEBUG',
     },
-    "123-456",
-  )
-  return new Request(
-    <APIGatewayEvent>(<unknown>event),
-    <Context>context ? context : {},
-    logger,
+    '123-456'
   )
+  return new Request(<APIGatewayEvent>(<unknown>event), <Context>context ? context : {}, logger)
 }
 
-describe("Request querystring", () => {
-  test("Null query string", () => {
+describe('Request querystring', () => {
+  test('Null query string', () => {
     const r = newReq({
       queryStringParameters: null,
     })
-    expect(r.containsQueryParam("123")).to.be.false
-    expect(r.getQueryParam("123")).to.be.null
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
   })
 
-  test("Empty query string", () => {
+  test('Empty query string', () => {
     const r = newReq({
       queryStringParameters: {},
     })
-    expect(r.containsQueryParam("123")).to.be.false
-    expect(r.getQueryParam("123")).to.be.null
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
   })
 
-  test("Valid query string", () => {
+  test('Valid query string', () => {
     const r = newReq({
-      queryStringParameters: { "123": "abc" },
+      queryStringParameters: { '123': 'abc' },
     })
-    expect(r.containsQueryParam("123")).to.be.true
-    expect(r.getQueryParam("123")).to.be.equals("abc")
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals('abc')
   })
 
-  test("Valid query string number", () => {
+  test('Valid query string number', () => {
     const r = newReq({
-      queryStringParameters: { "123": 456 },
+      queryStringParameters: { '123': 456 },
     })
-    expect(r.containsQueryParam("123")).to.be.true
-    expect(r.getQueryParam("123")).to.be.equals(456)
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals(456)
   })
 })
 
-describe("Request headers", () => {
-  test("Null headers", () => {
+describe('Request headers', () => {
+  test('Null headers', () => {
     const r = newReq({ headers: null })
-    expect(r.getHeader("123")).to.be.null
+    expect(r.getHeader('123')).to.be.null
   })
 
-  test("Empty headers", () => {
+  test('Empty headers', () => {
     const r = newReq({ headers: {} })
-    expect(r.getHeader("123")).to.be.null
+    expect(r.getHeader('123')).to.be.null
   })
 
-  test("Valid headers", () => {
-    const r = newReq({ headers: { "123": "abc" } })
-    expect(r.getHeader("123")).to.be.equals("abc")
+  test('Valid headers', () => {
+    const r = newReq({ headers: { '123': 'abc' } })
+    expect(r.getHeader('123')).to.be.equals('abc')
   })
 
-  test("Auth headers", () => {
-    const r = newReq({ headers: { Authorization: "abc" } })
-    expect(r.getAuthorizationHeader()).to.be.equals("abc")
+  test('Auth headers', () => {
+    const r = newReq({ headers: { Authorization: 'abc' } })
+    expect(r.getAuthorizationHeader()).to.be.equals('abc')
   })
 })
 
-describe("Request context", () => {
-  test("Null context", () => {
+describe('Request context', () => {
+  test('Null context', () => {
     const r = newReq({ requestContext: null })
-    expect(r.getContextParam("123")).to.be.null
+    expect(r.getContextParam('123')).to.be.null
   })
 
-  test("Empty context", () => {
+  test('Empty context', () => {
     const r = newReq({ requestContext: {} })
-    expect(r.getContextParam("123")).to.be.null
+    expect(r.getContextParam('123')).to.be.null
   })
 
-  test("Valid context", () => {
+  test('Valid context', () => {
     const r = newReq({
-      requestContext: { "123": "abc" },
+      requestContext: { '123': 'abc' },
     })
-    expect(r.getContextParam("123")).to.be.equals("abc")
+    expect(r.getContextParam('123')).to.be.equals('abc')
   })
 })
 
-describe("Request path params", () => {
-  test("Null path params", () => {
+describe('Request path params', () => {
+  test('Null path params', () => {
     const r = newReq({ pathParameters: null })
-    expect(r.containsPathParam("123")).to.be.false
-    expect(r.getPathParam("123")).to.be.null
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
     expect(r.getPathParams()).to.be.null
   })
 
-  test("Empty path params", () => {
+  test('Empty path params', () => {
     const r = newReq({ pathParameters: {} })
-    expect(r.containsPathParam("123")).to.be.false
-    expect(r.getPathParam("123")).to.be.null
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
     expect(r.getPathParams()).to.be.deep.equal({})
   })
 
-  test("Valid path params", () => {
-    const v = { "123": "abc" }
+  test('Valid path params', () => {
+    const v = { '123': 'abc' }
     const r = newReq({
       pathParameters: v,
     })
-    expect(r.containsPathParam("123")).to.be.true
-    expect(r.getPathParam("123")).to.be.equals("abc")
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
     expect(r.getPathParams()).to.be.deep.equal(v)
   })
 
-  test("Valid path param number", () => {
-    const v = { "123": 456 }
+  test('Valid path param number', () => {
+    const v = { '123': 456 }
     const r = newReq({
       pathParameters: v,
     })
-    expect(r.containsPathParam("123")).to.be.true
-    expect(r.getPathParam("123")).to.be.equals(456)
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals(456)
     expect(r.getPathParams()).to.be.deep.equal(v)
   })
 
-  test("Fix path params", () => {
-    const v = { "123": "abc" }
+  test('Fix path params', () => {
+    const v = { '123': 'abc' }
     const r = newReq({ pathParameters: null })
     r.setFixedPathParams(
-      Object.keys(v).map((k) => ({ name: k })),
-      ["/"].concat(Object.values(v)),
+      Object.keys(v).map(k => ({ name: k })),
+      ['/'].concat(Object.values(v))
     )
-    expect(r.containsPathParam("123")).to.be.true
-    expect(r.getPathParam("123")).to.be.equals("abc")
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
     expect(r.getPathParams()).to.be.deep.equal(v)
   })
 })
 
-describe("Request body", () => {
-  test("Null body", () => {
+describe('Request body', () => {
+  test('Null body', () => {
     const r = newReq({ body: null })
     expect(r.getBody()).to.be.null
   })
 
-  test("Empty body", () => {
+  test('Empty body', () => {
     const r = newReq({ body: {} })
     expect(r.getBody()).to.be.deep.equals({})
   })
 
-  test("Empty string body", () => {
-    const r = newReq({ body: "{}" })
+  test('Empty string body', () => {
+    const r = newReq({ body: '{}' })
     expect(r.getBody()).to.be.deep.equals({})
   })
 
-  test("Broken json string body", () => {
+  test('Broken json string body', () => {
     const r = newReq({ body: '{name": "Joe"}' })
     expect(r.getBody()).to.be.equals('{name": "Joe"}')
   })
 
-  test("Valid string body", () => {
+  test('Valid string body', () => {
     const r = newReq({ body: '{"name": "Joe"}' })
     expect(r.getBody()).to.be.deep.equals({
-      name: "Joe",
+      name: 'Joe',
     })
   })
 
-  test("Valid json body", () => {
-    const r = newReq({ body: { name: "Joe" } })
+  test('Valid json body', () => {
+    const r = newReq({ body: { name: 'Joe' } })
     expect(r.getBody()).to.be.deep.equals({
-      name: "Joe",
+      name: 'Joe',
     })
   })
 })
 
-describe("Request path/method", () => {
-  test("Null path/method", () => {
+describe('Request path/method', () => {
+  test('Null path/method', () => {
     const r = newReq({
       path: null,
       httpMethod: null,
@@ -187,76 +183,76 @@ describe("Request path/method", () => {
     expect(r.getMethod()).to.be.null
   })
 
-  test("Empty path/method", () => {
+  test('Empty path/method', () => {
     const r = newReq({
-      path: "",
-      httpMethod: "",
+      path: '',
+      httpMethod: '',
     })
-    expect(r.getPath()).to.be.a("string")
-    expect(r.getPath()).to.be.equals("")
-    expect(r.getMethod()).to.be.a("string")
-    expect(r.getMethod()).to.be.equals("")
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('')
+    expect(r.getMethod()).to.be.a('string')
+    expect(r.getMethod()).to.be.equals('')
   })
 
-  test("Valid method/path", () => {
+  test('Valid method/path', () => {
     const r = newReq({
-      path: "/root",
-      httpMethod: "GET",
+      path: '/root',
+      httpMethod: 'GET',
     })
-    expect(r.getPath()).to.be.a("string")
-    expect(r.getPath()).to.be.equals("/root")
-    expect(r.getMethod()).to.be.a("string")
-    expect(r.getMethod()).to.be.equals("GET")
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('/root')
+    expect(r.getMethod()).to.be.a('string')
+    expect(r.getMethod()).to.be.equals('GET')
   })
 })
 
-describe("Request ID", () => {
-  test("From context", () => {
-    const r = newReq({}, { awsRequestId: "123" })
+describe('Request ID', () => {
+  test('From context', () => {
+    const r = newReq({}, { awsRequestId: '123' })
     expect(r.getRequestID()).to.not.be.null
-    expect(r.getRequestID()).to.be.equals("123")
+    expect(r.getRequestID()).to.be.equals('123')
   })
 
-  test("From event", () => {
+  test('From event', () => {
     const r = newReq({
-      requestContext: { requestId: "123" },
+      requestContext: { requestId: '123' },
     })
     expect(r.getRequestID()).to.not.be.null
-    expect(r.getRequestID()).to.be.equals("123")
+    expect(r.getRequestID()).to.be.equals('123')
   })
 
-  test("unknown", () => {
+  test('unknown', () => {
     const r = newReq({})
     expect(r.getRequestID()).to.not.be.null
-    expect(r.getRequestID()).to.be.equals("unknown")
+    expect(r.getRequestID()).to.be.equals('unknown')
   })
 })
 
-describe("Request origin IP", () => {
-  test("From context", () => {
+describe('Request origin IP', () => {
+  test('From context', () => {
     const r = newReq({
       requestContext: {
-        identity: { sourceIp: "127.0.0.1" },
+        identity: { sourceIp: '127.0.0.1' },
       },
     })
     expect(r.getOriginIP()).to.not.be.null
-    expect(r.getOriginIP()).to.be.equals("127.0.0.1")
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
   })
 
-  test("From header", () => {
+  test('From header', () => {
     const r = newReq({
       headers: {
-        "X-Forwarded-For": "127.0.0.1",
+        'X-Forwarded-For': '127.0.0.1',
       },
     })
     expect(r.getOriginIP()).to.not.be.null
-    expect(r.getOriginIP()).to.be.equals("127.0.0.1")
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
   })
 
-  test("unknown", () => {
+  test('unknown', () => {
     const r = newReq({})
     expect(r.getOriginIP()).to.not.be.null
-    expect(r.getOriginIP()).to.be.equals("unknown")
+    expect(r.getOriginIP()).to.be.equals('unknown')
   })
 })