serverless-offline 9.1.7 → 9.2.2

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)
-  })
-})