chore: minimal switch [1870]

Author: yowainwright

test/test.js

@@ -1,8 +1,9 @@
 'use strict'
 
-const test = require('node:test')
-const assert = require('node:assert')
+/* eslint-env jest */
+const { describe, it, beforeEach, after } =  require('node:test');
 const compose = require('..')
+const assert = require('assert')
 
 function wait (ms) {
   return new Promise((resolve) => setTimeout(resolve, ms || 1))
@@ -12,8 +13,8 @@ function isPromise (x) {
   return x && typeof x.then === 'function'
 }
 
-async function testBaseFunctionality () {
-  await test('should work', async (t) => {
+function testBaseFunctionality() {
+  it('should work', async () => {
     const arr = []
     const stack = []
 
@@ -45,7 +46,7 @@ async function testBaseFunctionality () {
     assert.deepStrictEqual(arr.sort(), [1, 2, 3, 4, 5, 6])
   })
 
-  await test('should be able to be called twice', async (t) => {
+  it('should be able to be called twice', () => {
     const stack = []
 
     stack.push(async (context, next) => {
@@ -77,13 +78,15 @@ async function testBaseFunctionality () {
     const ctx2 = { arr: [] }
     const out = [1, 2, 3, 4, 5, 6]
 
-    await fn(ctx1)
-    assert.deepStrictEqual(ctx1.arr, out)
-    await fn(ctx2)
-    assert.deepStrictEqual(ctx2.arr, out)
+    return fn(ctx1).then(() => {
+      assert.deepEqual(out, ctx1.arr)
+      return fn(ctx2)
+    }).then(() => {
+      assert.deepEqual(out, ctx2.arr)
+    })
   })
 
-  await test('should create next functions that return a Promise', async (t) => {
+  it('should create next functions that return a Promise', function () {
     const stack = []
     const arr = []
     for (let i = 0; i < 5; i++) {
@@ -97,19 +100,19 @@ async function testBaseFunctionality () {
     compose(stack)({})
 
     for (const next of arr) {
-      assert.strictEqual(isPromise(next), true, 'one of the functions next is not a Promise')
+      assert(isPromise(next), 'one of the functions next is not a Promise')
     }
   })
 
-  await test('should work with 0 middleware', async (t) => {
-    await Promise.all([
+  it('should work with 0 middleware', function () {
+    return Promise.all([
       compose()({}),
       compose([])({}),
       compose([], [])({})
     ])
   })
 
-  await test('should only accept middleware as functions', (t) => {
+  it('should only accept middleware as functions', () => {
     const badTypes = [1, true, 'string', {}, undefined, Symbol('test')];
     [...badTypes, []].forEach((badType) => {
       assert.throws(() => compose([badType]), TypeError)
@@ -119,7 +122,7 @@ async function testBaseFunctionality () {
     })
   })
 
-  await test('should work when yielding at the end of the stack', async (t) => {
+  it('should work when yielding at the end of the stack', async () => {
     const stack = []
     let called = false
 
@@ -132,18 +135,18 @@ async function testBaseFunctionality () {
     assert(called)
   })
 
-  await test('should reject on errors in middleware', async (t) => {
+  it('should reject on errors in middleware', () => {
     const stack = []
 
     stack.push(() => { throw new Error() })
 
-    await assert.rejects(
+    return assert.rejects(
       compose(stack)({}),
       /Error/
     )
   })
 
-  await test('should keep the context', async (t) => {
+  it('should keep the context', () => {
     const ctx = {}
 
     const stack = []
@@ -163,10 +166,10 @@ async function testBaseFunctionality () {
       assert.deepStrictEqual(ctx2, ctx)
     })
 
-    await compose(stack)(ctx)
+    return compose(stack)(ctx)
   })
 
-  await test('should catch downstream errors', async (t) => {
+  it('should catch downstream errors', async () => {
     const arr = []
     const stack = []
 
@@ -191,32 +194,34 @@ async function testBaseFunctionality () {
     assert.deepStrictEqual(arr, [1, 6, 4, 2, 3])
   })
 
-  await test('should compose w/ next', async (t) => {
+  it('should compose w/ next', () => {
     let called = false
 
-    await compose([])({}, async () => {
+    return compose([])({}, async () => {
       called = true
+    }).then(function () {
+      assert(called)
     })
-    assert(called)
   })
 
-  await test('should handle errors in wrapped non-async functions', async (t) => {
+  it('should handle errors in wrapped non-async functions', () => {
     const stack = []
 
     stack.push(function () {
       throw new Error()
     })
 
-    await assert.rejects(
+    return assert.rejects(
       compose(stack)({}),
       /Error/
     )
   })
 
-  await test('should compose w/ other compositions', async (t) => {
+  // https://github.com/koajs/compose/pull/27#issuecomment-143109739
+  it('should compose w/ other compositions', () => {
     const called = []
 
-    await compose([
+    return compose([
       compose([
         (ctx, next) => {
           called.push(1)
@@ -231,14 +236,12 @@ async function testBaseFunctionality () {
         called.push(3)
         return next()
       }
-    ])({})
-
-    assert.deepStrictEqual(called, [1, 2, 3])
+    ])({}).then(() => assert.deepEqual(called, [1, 2, 3]))
   })
 
-  await test('should return a valid middleware', async (t) => {
+  it('should return a valid middleware', () => {
     let val = 0
-    await compose([
+    return compose([
       compose([
         (ctx, next) => {
           val++
@@ -253,12 +256,12 @@ async function testBaseFunctionality () {
         val++
         return next()
       }
-    ])({})
-
-    assert.strictEqual(val, 3)
+    ])({}).then(function () {
+      assert.strictEqual(val, 3)
+    })
   })
 
-  await test('should return last return value', async (t) => {
+  it('should return last return value', () => {
     const stack = []
 
     stack.push(async (context, next) => {
@@ -274,29 +277,30 @@ async function testBaseFunctionality () {
     })
 
     const next = () => 0
-    const result = await compose(stack)({}, next)
-    assert.strictEqual(result, 1)
+    return compose(stack)({}, next).then(function (val) {
+      assert.strictEqual(val, 1)
+    })
   })
 
-  await test('should not affect the original middleware array', (t) => {
+  it('should not affect the original middleware array', () => {
     const middleware = []
     const fn1 = (ctx, next) => {
       return next()
     }
     middleware.push(fn1)
 
     for (const fn of middleware) {
-      assert.strictEqual(fn, fn1)
+      assert.equal(fn, fn1)
     }
 
     compose(middleware)
 
     for (const fn of middleware) {
-      assert.strictEqual(fn, fn1)
+      assert.equal(fn, fn1)
     }
   })
 
-  await test('should not get stuck on the passed in next', async (t) => {
+  it('should not get stuck on the passed in next', () => {
     const middleware = [(ctx, next) => {
       ctx.middleware++
       return next()
@@ -306,57 +310,34 @@ async function testBaseFunctionality () {
       next: 0
     }
 
-    await compose(middleware)(ctx, (ctx, next) => {
+    return compose(middleware)(ctx, (ctx, next) => {
       ctx.next++
       return next()
+    }).then(() => {
+      assert.strictEqual(ctx.middleware, 1)
     })
-
-    assert.deepStrictEqual(ctx, { middleware: 1, next: 1 })
-  })
-
-  await test('production mode', async (t) => {
-    const OLD_ENV = process.env.NODE_ENV
-    process.env.NODE_ENV = 'production'
-
-    const arr = []
-    const stack = []
-
-    stack.push(async (context, next) => {
-      arr.push(1)
-      await next()
-      arr.push(3)
-    })
-
-    stack.push(async (context, next) => {
-      arr.push(2)
-      await next()
-    })
-
-    await compose(stack)({})
-    assert.deepStrictEqual(arr, [1, 2, 3])
-
-    process.env.NODE_ENV = OLD_ENV
   })
 }
 
-async function testDevErrors () {
-  await test('should only accept middleware as functions (dev)', (t) => {
+function testDevErrors() {
+  it('should only accept middleware as functions', () => {
     assert.throws(() => compose([{}]), TypeError)
   })
 
-  await test('should throw if next() is called multiple times', async (t) => {
-    await assert.rejects(
-      compose([
-        async (ctx, next) => {
-          await next()
-          await next()
-        }
-      ])({}),
-      /multiple times/
-    )
+  it('should throw if next() is called multiple times', () => {
+    return compose([
+      async (ctx, next) => {
+        await next()
+        await next()
+      }
+    ])({}).then(() => {
+      throw new Error('boom')
+    }, (err) => {
+      assert(/multiple times/.test(err.message))
+    })
   })
 
-  await test('should detect disconnected promise chains', async (t) => {
+  it('should detect disconnected promise chains', async () => {
     const middleware = [
       (ctx, next) => next(),
       (ctx, next) => {
@@ -373,15 +354,22 @@ async function testDevErrors () {
     )
   })
 }
+describe('Koa Compose', function () {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    delete require.cache[require.resolve('..')] // Most important - it clears the cache
+    process.env = { ...OLD_ENV, NODE_ENV: "production" }; // Make a copy
+  });
+
+  after(() => {
+    process.env = OLD_ENV; // Restore old environment
+  });
 
-test('Koa Compose', async (t) => {
-  const OLD_ENV = process.env.NODE_ENV
-  process.env.NODE_ENV = 'production'
-  await testBaseFunctionality()
-  process.env.NODE_ENV = OLD_ENV
+  testBaseFunctionality()
 })
 
-test('Koa Compose - Dev', async (t) => {
-  await testBaseFunctionality()
-  await testDevErrors()
+describe('Koa Compose - Dev', function () {
+  testBaseFunctionality()
+  testDevErrors()
 })