serverless-offline 9.2.0 → 9.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.2.0",
+  "version": "9.2.3",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "./src/index.js",
@@ -49,12 +49,6 @@
     "schedule",
     "websocket"
   ],
-  "files": [
-    "src/**",
-    "package.json",
-    "LICENSE",
-    "README.md"
-  ],
   "author": "David Hérault <dherault@gmail.com> (https://github.com/dherault)",
   "maintainers": [
     "Bilal Soylu (https://github.com/Bilal-S)",
@@ -195,7 +189,7 @@
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
     "@serverless/utils": "^6.7.0",
-    "aws-sdk": "^2.1187.0",
+    "aws-sdk": "^2.1195.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
@@ -217,7 +211,7 @@
   },
   "devDependencies": {
     "archiver": "^5.3.1",
-    "eslint": "^8.21.0",
+    "eslint": "^8.22.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",
@@ -227,7 +221,7 @@
     "lint-staged": "^13.0.3",
     "mocha": "^10.0.0",
     "prettier": "^2.7.1",
-    "serverless": "^3.21.0",
+    "serverless": "^3.22.0",
     "standard-version": "^9.5.0"
   },
   "peerDependencies": {

package/src/ServerlessOffline.js

@@ -245,9 +245,9 @@ export default class ServerlessOffline {
 
     log.notice()
     log.notice(
-      `Starting Offline at stage ${provider.stage} ${chalk.gray(
-        `(${provider.region})`,
-      )}`,
+      `Starting Offline at stage ${
+        this.#options.stage || provider.stage
+      } ${chalk.gray(`(${this.#options.region || provider.region})`)}`,
     )
     log.notice()
     log.debug('options:', this.#options)

package/src/events/http/Endpoint.js

@@ -10,11 +10,11 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 
 // velocity template defaults
 const defaultRequestTemplate = readFileSync(
-  resolve(__dirname, './templates/offline-default.req.vm'),
+  resolve(__dirname, 'templates/offline-default.req.vm'),
   'utf8',
 )
 const defaultResponseTemplate = readFileSync(
-  resolve(__dirname, './templates/offline-default.res.vm'),
+  resolve(__dirname, 'templates/offline-default.res.vm'),
   'utf8',
 )
 

package/src/events/http/authJWTSettingsExtractor.js

@@ -1,20 +1,24 @@
 import { log } from '@serverless/utils/log.js'
 
+function buildFailureResult(warningMessage) {
+  log.warning(warningMessage)
+
+  return {
+    unsupportedAuth: true,
+  }
+}
+
+function buildSuccessResult(authorizerName) {
+  return {
+    authorizerName,
+  }
+}
+
 export default function authJWTSettingsExtractor(
   endpoint,
   provider,
   ignoreJWTSignature,
 ) {
-  const buildFailureResult = (warningMessage) => {
-    log.warning(warningMessage)
-
-    return {
-      unsupportedAuth: true,
-    }
-  }
-
-  const buildSuccessResult = (authorizerName) => ({ authorizerName })
-
   const { authorizer } = endpoint
 
   if (!authorizer) {

package/src/lambda/handler-runner/HandlerRunner.js

@@ -24,9 +24,7 @@ export default class HandlerRunner {
 
   async #loadRunner() {
     const { useChildProcesses, useDocker, useInProcess } = this.#options
-
-    const { codeDir, functionKey, handler, runtime, servicePath, timeout } =
-      this.#funOptions
+    const { handler, runtime } = this.#funOptions
 
     log.debug(`Loading handler... (${handler})`)
 
@@ -71,16 +69,7 @@ export default class HandlerRunner {
           './in-process-runner/index.js'
         )
 
-        return new InProcessRunner(
-          {
-            codeDir,
-            functionKey,
-            handler,
-            servicePath,
-            timeout,
-          },
-          this.#env,
-        )
+        return new InProcessRunner(this.#funOptions, this.#env)
       }
 
       const { default: WorkerThreadRunner } = await import(

package/src/lambda/handler-runner/child-process-runner/ChildProcessRunner.js

@@ -59,7 +59,7 @@ export default class ChildProcessRunner {
             rej(data.error)
             return
           }
-          res(data)
+          res(data.result)
         })
       })
     } catch (err) {

package/src/lambda/handler-runner/child-process-runner/childProcessHelper.js

@@ -41,5 +41,5 @@ process.on('message', async (messageData) => {
   const result = await inProcessRunner.run(event, context)
 
   // TODO check serializeability (contains function, symbol etc)
-  process.send(result)
+  process.send({ result })
 })

package/src/lambda/handler-runner/python-runner/PythonRunner.js

@@ -17,6 +17,8 @@ export default class PythonRunner {
 
   #env = null
 
+  #handlerProcess = null
+
   #runtime = null
 
   constructor(funOptions, env) {
@@ -38,7 +40,7 @@ export default class PythonRunner {
 
     const [pythonExecutable] = this.#runtime.split('.')
 
-    this.handlerProcess = spawn(
+    this.#handlerProcess = spawn(
       pythonExecutable,
       [
         '-u',
@@ -52,14 +54,14 @@ export default class PythonRunner {
       },
     )
 
-    this.handlerProcess.stdout.readline = createInterface({
-      input: this.handlerProcess.stdout,
+    this.#handlerProcess.stdout.readline = createInterface({
+      input: this.#handlerProcess.stdout,
     })
   }
 
   // () => void
   cleanup() {
-    this.handlerProcess.kill()
+    this.#handlerProcess.kill()
   }
 
   #parsePayload(value) {
@@ -113,8 +115,8 @@ export default class PythonRunner {
         try {
           const parsed = this.#parsePayload(line.toString())
           if (parsed) {
-            this.handlerProcess.stdout.readline.removeListener('line', onLine)
-            this.handlerProcess.stderr.removeListener('data', onErr)
+            this.#handlerProcess.stdout.readline.removeListener('line', onLine)
+            this.#handlerProcess.stderr.removeListener('data', onErr)
             return accept(parsed)
           }
           return null
@@ -123,12 +125,12 @@ export default class PythonRunner {
         }
       }
 
-      this.handlerProcess.stdout.readline.on('line', onLine)
-      this.handlerProcess.stderr.on('data', onErr)
+      this.#handlerProcess.stdout.readline.on('line', onLine)
+      this.#handlerProcess.stderr.on('data', onErr)
 
       process.nextTick(() => {
-        this.handlerProcess.stdin.write(input)
-        this.handlerProcess.stdin.write('\n')
+        this.#handlerProcess.stdin.write(input)
+        this.#handlerProcess.stdin.write('\n')
       })
     })
   }

package/src/lambda/handler-runner/worker-thread-runner/WorkerThreadRunner.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { MessageChannel, Worker } from 'node:worker_threads'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
-const workerThreadHelperPath = resolve(__dirname, './workerThreadHelper.js')
+const workerThreadHelperPath = resolve(__dirname, 'workerThreadHelper.js')
 
 export default class WorkerThreadRunner {
   #workerThread = null

package/src/lambda/__tests__/LambdaContext.test.js

@@ -1,30 +0,0 @@
-import assert from 'node:assert'
-import LambdaContext from '../LambdaContext.js'
-
-describe('LambdaContext', () => {
-  it('should create LambdaContext with correct values', () => {
-    const functionName = 'foo'
-    const memorySize = 512
-    const requestId = 'abc123'
-
-    const lambdaContext = new LambdaContext(functionName, memorySize)
-    lambdaContext.setRequestId(requestId)
-    const context = lambdaContext.create()
-
-    const expected = {
-      awsRequestId: 'abc123',
-      callbackWaitsForEmptyEventLoop: true,
-      clientContext: undefined,
-      functionName: 'foo',
-      functionVersion: '$LATEST',
-      identity: undefined,
-      invokedFunctionArn: 'offline_invokedFunctionArn_for_foo',
-      logGroupName: 'offline_logGroupName_for_foo',
-      logStreamName: 'offline_logStreamName_for_foo',
-      memoryLimitInMB: '512',
-    }
-
-    // expect(context).toEqual(expected)
-    assert.deepEqual(context, expected)
-  })
-})

package/src/lambda/__tests__/LambdaFunction.test.js

@@ -1,196 +0,0 @@
-import assert from 'node:assert'
-import { dirname, resolve } from 'node:path'
-// import { performance } from 'node:perf_hooks'
-import { fileURLToPath } from 'node:url'
-import LambdaFunction from '../LambdaFunction.js'
-import { DEFAULT_LAMBDA_TIMEOUT } from '../../config/index.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-describe('LambdaFunction', () => {
-  const functionName = 'foo'
-
-  const serverless = {
-    config: {
-      serverlessPath: '',
-      servicePath: resolve(__dirname),
-    },
-    service: {
-      provider: {
-        runtime: 'nodejs12.x',
-      },
-    },
-  }
-
-  describe('Handler tests', () => {
-    ;[
-      {
-        description: 'should return result when handler is context.done',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.contextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler is context.done which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.contextDoneHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is context.succeed',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.contextSucceedHandler',
-      },
-      {
-        description:
-          'should return result when handler is context.succeed which is deferred',
-        expected: 'foo',
-        handler:
-          'fixtures/lambdaFunction-fixture.contextSucceedHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is a callback',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.callbackHandler',
-      },
-      {
-        description:
-          'should return result when handler is a callback which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.callbackHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler returns a promise',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.promiseHandler',
-      },
-      {
-        description:
-          'should return result when handler returns a promise which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.promiseHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is an async function',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction-fixture.asyncFunctionHandler',
-      },
-      // NOTE: mix and matching of callbacks and promises is not recommended,
-      // nonetheless, we test some of the behaviour to match AWS execution precedence
-      {
-        description:
-          'should return result when handler returns a callback but defines a callback parameter',
-        expected: 'Hello Promise!',
-        handler:
-          'fixtures/lambdaFunction-fixture.promiseWithDefinedCallbackHandler',
-      },
-      {
-        description:
-          'should return result when handler calls context.succeed and context.done',
-        expected: 'Hello Context.succeed!',
-        handler:
-          'fixtures/lambdaFunction-fixture.contextSucceedWithContextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback and context.done',
-        expected: 'Hello Callback!',
-        handler:
-          'fixtures/lambdaFunction-fixture.callbackWithContextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback and returns Promise',
-        expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction-fixture.callbackWithPromiseHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback inside returned Promise',
-        expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction-fixture.callbackInsidePromiseHandler',
-      },
-    ].forEach(({ description, expected, handler }) => {
-      it(description, async () => {
-        const functionDefinition = {
-          handler,
-        }
-        const options = {}
-        const lambdaFunction = new LambdaFunction(
-          functionName,
-          functionDefinition,
-          serverless,
-          options,
-        )
-        const result = await lambdaFunction.runHandler()
-
-        await lambdaFunction.cleanup()
-
-        assert.equal(result, expected)
-      })
-    })
-  })
-
-  it('should pass remaining time to LambdaContext', async () => {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction-fixture.remainingExecutionTimeHandler',
-    }
-    const options = {}
-    const lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      serverless,
-      options,
-    )
-    const [first, second, third] = await lambdaFunction.runHandler()
-
-    await lambdaFunction.cleanup()
-
-    // handler "pauses" for 100 ms
-    assert.ok(first > second - 100)
-    assert.ok(second > third - 200)
-  })
-
-  it.skip('should use default lambda timeout when timeout is not provided', async () => {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction-fixture.defaultTimeoutHandler',
-    }
-    const options = {}
-    const lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      serverless,
-      options,
-    )
-    const remainingTime = await lambdaFunction.runHandler()
-
-    await lambdaFunction.cleanup()
-
-    assert.ok(remainingTime < DEFAULT_LAMBDA_TIMEOUT * 1000)
-
-    // result might be flaky/unreliable:
-    // (assmuning handler runs no longer than 1 s)
-    assert.ok(remainingTime + 1000 > DEFAULT_LAMBDA_TIMEOUT * 1000)
-  })
-
-  // // might run flaky (unreliable)
-  // test('executionTimeInMillis should return execution time', async () => {
-  //   const functionDefinition = {
-  //     handler: 'fixtures/lambdaFunction-fixture.executionTimeInMillisHandler',
-  //   }
-  //   const options = {}
-  //   const lambdaFunction = new LambdaFunction(
-  //     functionName,
-  //     functionDefinition,
-  //     provider,
-  //     config,
-  //     options,
-  //   )
-  //   const timerStart = performance.now()
-  //   await lambdaFunction.runHandler()
-  //   const timerEnd = performance.now()
-  //
-  //   expect(lambdaFunction.executionTimeInMillis).toBeLessThanOrEqual(
-  //     timerEnd - timerStart + 10,
-  //   )
-  // })
-})

package/src/lambda/__tests__/fixtures/Lambda/LambdaFunctionThatReturnsJSONObject-fixture.js

@@ -1,46 +0,0 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import LambdaFunction from '../../../LambdaFunction.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export default class LambdaFunctionThatReturnsJSONObject {
-  #lambdaFunction
-
-  options = {}
-
-  serverless = {
-    config: {
-      serverlessPath: '',
-      servicePath: resolve(__dirname, '../..'),
-    },
-    service: {
-      provider: {
-        runtime: 'nodejs12.x',
-      },
-    },
-  }
-
-  listFunctionNames() {
-    return ['foo']
-  }
-
-  getByFunctionName(functionName) {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction-fixture.asyncFunctionHandlerObject',
-    }
-
-    this.#lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      this.serverless,
-      this.options,
-    )
-
-    return this.#lambdaFunction
-  }
-
-  async cleanup() {
-    await this.#lambdaFunction.cleanup()
-  }
-}

package/src/lambda/__tests__/fixtures/Lambda/LambdaFunctionThatReturnsNativeString-fixture.js

@@ -1,46 +0,0 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import LambdaFunction from '../../../LambdaFunction.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export default class LambdaFunctionThatReturnsNativeString {
-  #lambdaFunction
-
-  options = {}
-
-  serverless = {
-    config: {
-      serverlessPath: '',
-      servicePath: resolve(__dirname, '../..'),
-    },
-    service: {
-      provider: {
-        runtime: 'nodejs12.x',
-      },
-    },
-  }
-
-  listFunctionNames() {
-    return ['foo']
-  }
-
-  getByFunctionName(functionName) {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction-fixture.asyncFunctionHandler',
-    }
-
-    this.#lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      this.serverless,
-      this.options,
-    )
-
-    return this.#lambdaFunction
-  }
-
-  async cleanup() {
-    await this.#lambdaFunction.cleanup()
-  }
-}

package/src/lambda/__tests__/fixtures/Lambda/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/src/lambda/__tests__/fixtures/lambdaFunction-fixture.js

@@ -1,145 +0,0 @@
-'use strict'
-
-exports.contextDoneHandler = function contextDoneHandler(event, context) {
-  context.done(null, 'foo')
-}
-
-exports.contextDoneHandlerDeferred = function contextDoneHandlerDeferred(
-  event,
-  context,
-) {
-  setTimeout(() => context.done(null, 'foo'), 100)
-}
-
-exports.contextSucceedHandler = function contextSucceedHandler(event, context) {
-  context.succeed('foo')
-}
-
-exports.contextSucceedHandlerDeferred = function contextSucceedHandlerDeferred(
-  event,
-  context,
-) {
-  setTimeout(() => context.succeed('foo'), 100)
-}
-
-exports.callbackHandler = function callbackHandler(event, context, callback) {
-  callback(null, 'foo')
-}
-
-exports.callbackHandlerDeferred = function callbackHandlerDeferred(
-  event,
-  context,
-  callback,
-) {
-  setTimeout(() => callback(null, 'foo'), 100)
-}
-
-exports.promiseHandler = function promiseHandler() {
-  return Promise.resolve('foo')
-}
-
-exports.promiseHandlerDeferred = function promiseDeferred() {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve('foo'), 100)
-  })
-}
-
-exports.asyncFunctionHandler = async function asyncFunctionHandler() {
-  return 'foo'
-}
-
-exports.asyncFunctionHandlerObject = async function asyncFunctionHandler() {
-  return {
-    foo: 'bar',
-  }
-}
-
-// we deliberately test the case where a 'callback' is defined
-// in the handler, but a promise is being returned to protect from a
-// potential naive implementation, e.g.
-//
-// const { promisify } = 'utils'
-// const promisifiedHandler = handler.length === 3 ? promisify(handler) : handler
-//
-// if someone would return a promise, but also defines callback, without using it
-// the handler would not be returning anything
-exports.promiseWithDefinedCallbackHandler =
-  function promiseWithDefinedCallbackHandler(
-    event, // eslint-disable-line no-unused-vars
-    context, // eslint-disable-line no-unused-vars
-    callback, // eslint-disable-line no-unused-vars
-  ) {
-    return Promise.resolve('Hello Promise!')
-  }
-
-exports.contextSucceedWithContextDoneHandler =
-  function contextSucceedWithContextDoneHandler(event, context) {
-    context.succeed('Hello Context.succeed!')
-
-    context.done(null, 'Hello Context.done!')
-  }
-
-exports.callbackWithContextDoneHandler =
-  function callbackWithContextDoneHandler(event, context, callback) {
-    callback(null, 'Hello Callback!')
-
-    context.done(null, 'Hello Context.done!')
-  }
-
-exports.callbackWithPromiseHandler = function callbackWithPromiseHandler(
-  event,
-  context,
-  callback,
-) {
-  callback(null, 'Hello Callback!')
-
-  return Promise.resolve('Hello Promise!')
-}
-
-exports.callbackInsidePromiseHandler = function callbackInsidePromiseHandler(
-  event,
-  context,
-  callback,
-) {
-  return new Promise((resolve) => {
-    callback(null, 'Hello Callback!')
-
-    resolve('Hello Promise!')
-  })
-}
-
-exports.requestIdHandler = async function requestIdHandler(event, context) {
-  return context.awsRequestId
-}
-
-exports.remainingExecutionTimeHandler =
-  async function remainingExecutionTimeHandler(event, context) {
-    const first = context.getRemainingTimeInMillis()
-
-    await new Promise((resolve) => {
-      setTimeout(resolve, 100)
-    })
-
-    const second = context.getRemainingTimeInMillis()
-
-    await new Promise((resolve) => {
-      setTimeout(resolve, 200)
-    })
-
-    const third = context.getRemainingTimeInMillis()
-
-    return [first, second, third]
-  }
-
-exports.defaultTimeoutHandler = async function defaultTimeoutHandler(
-  event,
-  context,
-) {
-  return context.getRemainingTimeInMillis()
-}
-
-exports.executionTimeInMillisHandler = function executionTimeInMillisHandler() {
-  return new Promise((resolve) => {
-    setTimeout(resolve, 100)
-  })
-}

package/src/lambda/__tests__/fixtures/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/src/lambda/__tests__/routes/invocations/InvocationsController.test.js

@@ -1,42 +0,0 @@
-import assert from 'node:assert'
-import InvocationsController from '../../../routes/invocations/InvocationsController.js'
-import LambdaFunctionThatReturnsJSONObject from '../../fixtures/Lambda/LambdaFunctionThatReturnsJSONObject-fixture.js'
-import LambdaFunctionThatReturnsNativeString from '../../fixtures/Lambda/LambdaFunctionThatReturnsNativeString-fixture.js'
-
-describe('InvocationController', () => {
-  const functionName = 'foo'
-
-  describe('when event type is "RequestResponse"', () => {
-    const eventType = 'RequestResponse'
-
-    it('should return json object if lambda response is json', async () => {
-      const expected = {
-        Payload: {
-          foo: 'bar',
-        },
-        StatusCode: 200,
-      }
-
-      const lambdaFunction = new LambdaFunctionThatReturnsJSONObject()
-      const invocationController = new InvocationsController(lambdaFunction)
-      const result = await invocationController.invoke(functionName, eventType)
-      await lambdaFunction.cleanup()
-
-      assert.deepEqual(result, expected)
-    })
-
-    it('should wrap native string responses with ""', async () => {
-      const expected = {
-        Payload: '"foo"',
-        StatusCode: 200,
-      }
-
-      const lambdaFunction = new LambdaFunctionThatReturnsNativeString()
-      const invocationController = new InvocationsController(lambdaFunction)
-      const result = await invocationController.invoke(functionName, eventType)
-      await lambdaFunction.cleanup()
-
-      assert.deepEqual(result, expected)
-    })
-  })
-})

package/src/utils/__tests__/createUniqueId.test.js

@@ -1,18 +0,0 @@
-import assert from 'node:assert'
-import createUniqueId from '../createUniqueId.js'
-
-describe('createUniqueId', () => {
-  it('should be unique', () => {
-    const items = 100000
-    const set = new Set(Array.from(Array(items)).map(createUniqueId))
-
-    assert.equal(set.size, items)
-  })
-
-  it('should be a 36 character string', () => {
-    const id = createUniqueId()
-
-    assert.equal(typeof id, 'string')
-    assert.equal(id.length, 36)
-  })
-})

package/src/utils/__tests__/formatToClfTime.test.js

@@ -1,14 +0,0 @@
-import assert from 'node:assert'
-import formatToClfTime from '../formatToClfTime.js'
-
-const { now } = Date
-
-describe('formatToClfTime', () => {
-  it('should return "common log format" formatted time', () => {
-    const millis = now()
-    const result = formatToClfTime(millis)
-
-    // expected: 17/Dec/1995:03:24:00 -0500 (with varying offset)
-    assert.match(result, /([\w:/]+\s[+-]\d{4})/)
-  })
-})

package/src/utils/__tests__/generateHapiPath.test.js

@@ -1,46 +0,0 @@
-import assert from 'node:assert'
-import generateHapiPath from '../generateHapiPath.js'
-
-const serverless = {
-  service: {
-    provider: {
-      stage: 'dev',
-    },
-  },
-}
-
-describe('generateHapiPath', () => {
-  it('should generate url starting with a slash', () => {
-    const options = {}
-    const result = generateHapiPath('users', options, serverless)
-    assert.equal(result[0], '/')
-  })
-
-  it('should generate url with the stage prepended', () => {
-    const options = {}
-    const result = generateHapiPath('users', options, serverless)
-    assert.equal(result, '/dev/users')
-  })
-
-  describe('when a prefix option is set', () => {
-    it('the url should add the prefix', () => {
-      const options = { prefix: 'some-prefix' }
-      const result = generateHapiPath('users', options, serverless)
-      assert.equal(result, '/some-prefix/dev/users')
-    })
-  })
-
-  describe('when the noPrependStageInUrl option is set', () => {
-    it('the url should omit the stage', () => {
-      const options = { noPrependStageInUrl: true }
-      const result = generateHapiPath('users', options, serverless)
-      assert.equal(result, '/users')
-    })
-  })
-
-  it('the stage from options should override stage from serverless config', () => {
-    const options = { stage: 'prod' }
-    const result = generateHapiPath('users', options, serverless)
-    assert.equal(result, '/prod/users')
-  })
-})

package/src/utils/__tests__/lowerCaseKeys.test.js

@@ -1,30 +0,0 @@
-import assert from 'node:assert'
-import lowerCaseKeys from '../lowerCaseKeys.js'
-
-describe('lowerCaseKeys', () => {
-  it('should handle empty object', () => {
-    const result = lowerCaseKeys({})
-    assert.deepEqual(result, {})
-  })
-
-  it('should handle object with one key', () => {
-    const result = lowerCaseKeys({ 'Some-Key': 'value' })
-    assert.deepEqual(result, { 'some-key': 'value' })
-  })
-
-  it('should handle object with multiple keys', () => {
-    const result = lowerCaseKeys({
-      'already-lowercase': 'cool',
-      'Another-Key': 'anotherValue',
-      'lOts-OF-CAPitaLs': 'ButThisIsNotTouched',
-      'Some-Key': 'value',
-    })
-
-    assert.deepEqual(result, {
-      'already-lowercase': 'cool',
-      'another-key': 'anotherValue',
-      'lots-of-capitals': 'ButThisIsNotTouched',
-      'some-key': 'value',
-    })
-  })
-})

package/src/utils/__tests__/parseHeaders.test.js

@@ -1,13 +0,0 @@
-import assert from 'node:assert'
-// uses the same tests as parseMultiValueHeaders
-import tests from './parseMultiValueHeaders.test.js'
-import parseHeaders from '../parseHeaders.js'
-
-describe('parseQueryStringParameters', () => {
-  tests.forEach(({ description, expected, param }) => {
-    it(`should return ${description}`, () => {
-      const result = parseHeaders(param)
-      assert.deepEqual(result, expected)
-    })
-  })
-})

package/src/utils/__tests__/parseMultiValueHeaders.test.js

@@ -1,24 +0,0 @@
-import assert from 'node:assert'
-import parseMultiValueHeaders from '../parseMultiValueHeaders.js'
-
-// TODO need more tests
-const tests = [
-  {
-    description: 'no parameter (empty array)',
-    expected: null,
-    expectedMulti: null,
-    param: [],
-  },
-]
-
-describe('parseMultiValueHeaders', () => {
-  tests.forEach(({ description, expectedMulti, param }) => {
-    it(`should return ${description}`, () => {
-      const resultMulti = parseMultiValueHeaders(param)
-      assert.deepEqual(resultMulti, expectedMulti)
-    })
-  })
-})
-
-// export tests for parseHeaders
-export default tests

package/src/utils/__tests__/parseMultiValueQueryStringParameters.test.js

@@ -1,159 +0,0 @@
-import assert from 'node:assert'
-import parseMultiValueQueryStringParameters from '../parseMultiValueQueryStringParameters.js'
-
-const tests = [
-  {
-    description: 'no parameter (empty string)',
-    expected: null,
-    expectedMulti: null,
-    param: '',
-  },
-
-  {
-    description: 'string parameter',
-    expected: { foo: 'bar' },
-    expectedMulti: { foo: ['bar'] },
-    param: 'foo=bar',
-  },
-
-  {
-    description: 'number parameter (no type casting)',
-    expected: { foo: '1' },
-    expectedMulti: { foo: ['1'] },
-    param: 'foo=1',
-  },
-
-  {
-    description: 'boolean parameter (no type casting)',
-    expected: { foo: 'true' },
-    expectedMulti: { foo: ['true'] },
-    param: 'foo=true',
-  },
-
-  {
-    description: 'multiple parameters',
-    expected: { bar: 'test2', foo: 'test1' },
-    expectedMulti: { bar: ['test2'], foo: ['test1'] },
-    param: 'foo=test1&bar=test2',
-  },
-
-  {
-    description: 'multiple parameters, same keys',
-    expected: { foo: 'foobar' },
-    expectedMulti: { foo: ['test', 'foobar'] },
-    param: 'foo=test&foo=foobar',
-  },
-
-  {
-    description: 'multiple parameters, same keys, different casing',
-    expected: { foo: 'test', FOO: 'FOOBAR' },
-    expectedMulti: { foo: ['test'], FOO: ['FOOBAR'] },
-    param: 'foo=test&FOO=FOOBAR',
-  },
-
-  {
-    description: 'multiple parameters, same keys, same values',
-    expected: { foo: 'test' },
-    expectedMulti: { foo: ['test', 'test'] },
-    param: 'foo=test&foo=test',
-  },
-
-  {
-    description: 'no value',
-    expected: { foo: '' },
-    expectedMulti: { foo: [''] },
-    param: 'foo',
-  },
-
-  {
-    description: 'no value with =',
-    expected: { foo: '' },
-    expectedMulti: { foo: [''] },
-    param: 'foo=',
-  },
-
-  {
-    description: 'no value with &',
-    expected: { foo: '' },
-    expectedMulti: { foo: [''] },
-    param: 'foo&',
-  },
-
-  {
-    description: 'no value with = and &',
-    expected: { foo: '' },
-    expectedMulti: { foo: [''] },
-    param: 'foo=&',
-  },
-
-  {
-    description: 'value is whitespace',
-    expected: { foo: ' ' },
-    expectedMulti: { foo: [' '] },
-    param: 'foo=%20',
-  },
-
-  {
-    description: 'key and value have whitespace',
-    expected: { ' foo ': ' test ' },
-    expectedMulti: { ' foo ': [' test '] },
-    param: '%20foo%20=%20test%20',
-  },
-
-  {
-    description: 'unicode',
-    expected: { Σ: '😋' },
-    expectedMulti: { Σ: ['😋'] },
-    param: 'Σ=😋',
-  },
-
-  {
-    description: 'encoded', // encodeURIComponent
-    expected: { '?=/&:': '?=/&:' },
-    expectedMulti: { '?=/&:': ['?=/&:'] },
-    param: '%3F%3D%2F%26%3A=%3F%3D%2F%26%3A',
-  },
-
-  {
-    description: 'end of line',
-    expected: { '\n': '\n' },
-    expectedMulti: { '\n': ['\n'] },
-    param: '%0A=%0A',
-  },
-
-  // silly test section:
-  {
-    description: 'silly I.',
-    expected: { test: '?' },
-    expectedMulti: { test: ['?'] },
-    param: 'test=?',
-  },
-
-  {
-    description: 'silly II.',
-    expected: { test: '/' },
-    expectedMulti: { test: ['/'] },
-    param: 'test=/',
-  },
-
-  {
-    description: 'silly III.',
-    expected: { test: '=' },
-    expectedMulti: { test: ['='] },
-    param: 'test==',
-  },
-]
-
-describe('parseMultiValueQueryStringParameters', () => {
-  tests.forEach(({ description, expectedMulti, param }) => {
-    const url = `foo?${param}`
-
-    it(`should return ${description}`, () => {
-      const resultMulti = parseMultiValueQueryStringParameters(url)
-      assert.deepEqual(resultMulti, expectedMulti)
-    })
-  })
-})
-
-// export tests for parseQueryStringParameters
-export default tests

package/src/utils/__tests__/parseQueryStringParameters.test.js

@@ -1,15 +0,0 @@
-import assert from 'node:assert'
-// uses the same tests as parseMultiValueQueryStringParameters
-import tests from './parseMultiValueQueryStringParameters.test.js'
-import parseQueryStringParameters from '../parseQueryStringParameters.js'
-
-describe('parseQueryStringParameters', () => {
-  tests.forEach(({ description, expected, param }) => {
-    const url = `/foo?${param}`
-
-    it(`should return ${description}`, () => {
-      const result = parseQueryStringParameters(url)
-      assert.deepEqual(result, expected)
-    })
-  })
-})

package/src/utils/__tests__/splitHandlerPathAndName.test.js

@@ -1,54 +0,0 @@
-import assert from 'node:assert'
-import splitHandlerPathAndName from '../splitHandlerPathAndName.js'
-
-const tests = [
-  {
-    description: 'ruby handler with namespace resolution operator ::',
-    expected: ['./src/somefolder/source', 'LambdaFunctions::Handler.process'],
-    handler: './src/somefolder/source.LambdaFunctions::Handler.process',
-  },
-  {
-    description: 'ruby handler with multiple namespace resolution operators ::',
-    expected: [
-      './src/somefolder/source',
-      'Functions::LambdaFunctions::Handler.process',
-    ],
-    handler:
-      './src/somefolder/source.Functions::LambdaFunctions::Handler.process',
-  },
-  {
-    description: 'ruby handler with namespace resolution operator ::, unnested',
-    expected: ['source', 'LambdaFunctions::Handler.process'],
-    handler: 'source.LambdaFunctions::Handler.process',
-  },
-  {
-    description:
-      'ruby handler with multiple namespace resolution operators ::, unnested',
-    expected: ['./source', 'Functions::LambdaFunctions::Handler.process'],
-    handler: './source.Functions::LambdaFunctions::Handler.process',
-  },
-  {
-    description: 'ruby handler from kernel',
-    expected: ['./src/somefolder/function', 'handler'],
-    handler: './src/somefolder/function.handler',
-  },
-  {
-    description: 'generic handler',
-    expected: ['./src/somefolder/.handlers/handler', 'run'],
-    handler: './src/somefolder/.handlers/handler.run',
-  },
-  {
-    description: 'generic handler, unnested',
-    expected: ['handler', 'run'],
-    handler: 'handler.run',
-  },
-]
-
-describe('splitHandlerPathAndName', () => {
-  tests.forEach(({ description, expected, handler }) => {
-    it(`should split ${description}`, () => {
-      const result = splitHandlerPathAndName(handler)
-      assert.deepEqual(result, expected)
-    })
-  })
-})

package/src/utils/__tests__/unflatten.test.js

@@ -1,32 +0,0 @@
-import assert from 'node:assert'
-import unflatten from '../unflatten.js'
-
-describe('unflatten', () => {
-  it('should work with empty array parameter', () => {
-    const value = []
-    const out = unflatten(value, 2)
-    const expected = []
-
-    assert.deepEqual(out, expected)
-  })
-
-  it('should work with single pair parameter', () => {
-    const value = ['a', 1]
-    const out = unflatten(value, 2)
-    const expected = [['a', 1]]
-
-    assert.deepEqual(out, expected)
-  })
-
-  it('should work with multiple pair parameters', () => {
-    const value = ['a', 1, 'b', 2, 'c', 3]
-    const out = unflatten(value, 2)
-    const expected = [
-      ['a', 1],
-      ['b', 2],
-      ['c', 3],
-    ]
-
-    assert.deepEqual(out, expected)
-  })
-})