als-session/tests/validate-options.test.js

Flexible and secure session management library for Node.js using encrypted cookies.

const { describe, it, before, after, beforeEach } = require('node:test');
const assert = require('node:assert');
const validateOptions = require('../lib/validate-options.js')
describe('Basic tests', () => {

   it('Defalt values', () => {
      const { maxAge, logger, methods, name, sameSite } = validateOptions({})
      assert(maxAge === 60 * 60 * 24 * 30)
      assert(logger === console.log)
      assert(name === 'session')
      assert.deepStrictEqual(methods, ['GET', 'PUT', 'POST', 'PATCH', 'DELETE'])
      assert(sameSite === 'lax')
   })

   it('should be case-insensitive for sameSite', () => {
      const { sameSite } = validateOptions({ sameSite: 'LaX' })
      assert(sameSite === 'lax')
   });

   it('name', () => {
      assert.throws(() => validateOptions({ maxAge: '' }))
      assert.throws(() => validateOptions({ maxAge: 'a' }))
      assert.throws(() => validateOptions({ maxAge: {} }))
      assert.throws(() => validateOptions({ maxAge: [] }))
      assert.throws(() => validateOptions({ maxAge: 0 }))
      assert.throws(() => validateOptions({ maxAge: -2 }))

      assert.doesNotThrow(() => validateOptions({ name: null }))
      assert.doesNotThrow(() => validateOptions({ name: undefined }))
   })

   it('maxAge', () => {
      assert.throws(() => validateOptions({ maxAge: '' }))
      assert.throws(() => validateOptions({ maxAge: {} }))
      assert.throws(() => validateOptions({ maxAge: [] }))
      assert.throws(() => validateOptions({ maxAge: 0 }))
      assert.throws(() => validateOptions({ maxAge: -2 }))
      assert.throws(() => validateOptions({ maxAge: '1000' }))

      assert.doesNotThrow(() => validateOptions({ maxAge: null }))
      assert.doesNotThrow(() => validateOptions({ maxAge: undefined }))
      assert.doesNotThrow(() => validateOptions({ maxAge: 1 }))
   })

   it('logger', () => {
      assert(validateOptions({ logger: ' ' }).logger === console.log)
      assert(validateOptions({ logger: {} }).logger === console.log)
      assert(validateOptions({ logger: [] }).logger === console.log)
      assert(validateOptions({ logger: 0 }).logger === console.log)
      assert(validateOptions({ logger: -2 }).logger === console.log)
      assert(validateOptions({ logger: '1000' }).logger === console.log)
      assert(validateOptions({ logger: '' }).logger === console.log)
      assert(validateOptions({ logger: null }).logger === console.log)
      assert(validateOptions({ logger: undefined }).logger === console.log)
      assert.doesNotThrow(() => validateOptions({ logger: () => { } }))
   })

   it('methos', () => {
      const def = ['GET', 'PUT', 'POST', 'PATCH', 'DELETE'];
      assert.deepStrictEqual(validateOptions({ methods: ' ' }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: {} }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: 0 }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: -2 }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: '1000' }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: '' }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: null }).methods, def)
      assert.deepStrictEqual(validateOptions({ methods: undefined }).methods, def)

      assert.throws(() => validateOptions({ methods: [] }))
      assert.deepStrictEqual(validateOptions({ methods: ['put', 'post'] }).methods, ['PUT', 'POST'])
   })

   it('Should throw error for invalid methods input', () => {
      assert.throws(() => validateOptions({ methods: [] }));
   });

   it('Should normalize methods to upper case', () => {
      const { methods } = validateOptions({ methods: ['get', 'post'] });
      assert.deepStrictEqual(methods, ['GET', 'POST'], 'Methods should be converted to upper case');
   });

})