additional specs for previous rework

spec/router-spec.js

@@ -206,7 +206,7 @@ describe("router", () => {
       expect(router.wrap.bind(null, route, [])).not.toThrow()
     })
 
-    it("wrap only works for routing functions with (request, prefix, middleware) signature", () => {
+    it("wrap only works for routing functions with (request, prefix, handler_only) signature", () => {
       // best way prevent this is to use the function signatures
       // signatures argument length
       expect(() => {
@@ -217,8 +217,72 @@ describe("router", () => {
         router.wrap((a) => {}, [])
       }).toThrowError(/route being passed to/)
 
-      // exceeding 3 is ok
-      router.wrap((a, b, c, d) => { return () => {} }, [()=>{}])
+      // exceeding 3 is not ok either
+      expect(() => {
+        router.wrap((a, b, c, d) => { return [()=>{}, ""] }, [()=>{}])
+      }).toThrowError(/route being passed to/)
+
+      // the function takes 3 arguments, but the return is not right
+      expect(() => {
+        router.wrap((a, b, c) => { return "ok" }, [()=>{}])
+      }).toThrowError(/route being passed to/)
+
+      router.wrap((a, b, c) => { return [()=>{}, ""] }, [()=>{}])
+    })
+
+    it("wrapped middleware only initialize once", (done) => {
+      let init = 0
+      let called = 0
+
+      const middleware = (handler) => {
+        init += 1
+        return (req) => {
+          called += 1
+          return handler(req)
+        }
+      }
+
+      // route path (compose)
+      const route_path = router.wrap(["GET", "/test", [], "ok"], middleware)
+
+      // define path (compose_args)
+      const test = (req, prefix, handler_only) => {
+        return [() => {}, "/test"]
+      }
+      const define_path = router.wrap(test, middleware)
+
+
+      const test_run = (fn, req, count, callback) => {
+        if (count > 3) {
+          return callback()
+        }
+        const t = test_run.bind(undefined, fn, req, count + 1, callback)
+        fn(req).then(t)
+      }
+
+      test_run(route_path, {url: "/test", method: "GET"}, 0, () => {
+        expect(init).toBe(2)
+        expect(called).toBe(4)
+        test_run(define_path, {url: "/test"}, 0, () => {
+          expect(init).toBe(2)
+          expect(called).toBe(8)
+          done()
+        })
+      })
+    })
+
+    it("wrapped middleware (with compose_args) will remove _routing when passed to handler", (done) => {
+      const test = (req, prefix, handler_only) => {
+        const test_handler = (req) => {
+          expect(req._routing).toBe(undefined)
+          expect(Object.keys(req)).toEqual(["a", "url"])
+          done()
+        }
+        return [test_handler, "/test"]
+      }
+      const middleware = (handler) => { return (req) => { return handler(req) }}
+      const route = router.wrap(test, middleware)
+      route({ a: 1, url: "/test" })
     })
   })
 

spec/spirit-router-spec.js

@@ -321,6 +321,43 @@ describe("router-spec", () => {
     })
   })
 
+  it("wrapped routes can compose by nesting itself too", (done) => {
+    let called = 0
+
+    const middleware = (handler) => {
+      return (req) => {
+        called += 1
+        return handler(req).then((resp) => {
+          if (!resp) return resp
+          resp.body += "-"
+          return resp
+        })
+      }
+    }
+
+    const rr1 = route.define("/testing", [
+      route.wrap(["get", "/test1", [], undefined], middleware)
+    ])
+    const rr2 = route.define("/testing", [
+      route.wrap(["get", "/test2", [], "home"], middleware)
+    ])
+
+    const r = route.define([
+      route.wrap(rr1, middleware),
+      route.wrap(rr2, middleware)
+    ])
+
+    const result = r({ method: "GET", url: "/testing/test2" })
+    result.then((resp) => {
+      expect(resp).toEqual(jasmine.objectContaining({
+        status: 200,
+        body: "home--"
+      }))
+      expect(called).toBe(3)
+      done()
+    })
+  })
+
   it("resolves a route that returns a response body of a promise", (done) => {
     const test = () => {
       const p = Promise.resolve("hi")

src/router.js

@@ -30,6 +30,7 @@ const _lookup = (route, req_method, req_path) => {
  */
 const wrap_router = (Route) => {
   return (request, prefix) => {
+    if (typeof prefix !== "string") prefix = ""
     const url = request.url.substring(prefix.length)
     const params = _lookup(Route, request.method, url)
     if (!params) {
@@ -147,11 +148,10 @@ const wrap = (route, middleware) => {
   }
 
   // otherwise wrapping a function (from define)
-  if (route.length < 3) {
-    throw new Error("Unable to apply middlewares to route, route being passed to `wrap` does not take middlewares.")
-  }
-
+  const err_msg = "Unable to apply middlewares to route, route being passed to `wrap` does not take middlewares."
+  if (route.length !== 3) throw new Error(err_msg)
   const r = route(undefined, undefined, true)
+  if (typeof r[0] !== "function" || typeof r[1] !== "string") throw new Error(err_msg)
   return wrap_context_router(compose_args(r[0], middleware), r[1], "_routing")
 }