feat(context): support for creating fake context for testing

Author: thetutlage

adonis-typings/index.ts

@@ -13,16 +13,30 @@
 /// <reference types="@poppinss/logger/build/adonis-typings" />
 
 declare module '@ioc:Adonis/Src/HttpContext' {
-  import { HttpContextContract as BaseContextContract } from '@poppinss/http-server/contracts'
+  import { HttpContextContract as BaseContextContract, ServerConfig } from '@poppinss/http-server/contracts'
   import { ResponseContract } from '@ioc:Adonis/Src/Response'
   import { RequestContract } from '@ioc:Adonis/Src/Request'
   import { LoggerContract } from '@ioc:Adonis/Src/Logger'
+  import { IncomingMessage, ServerResponse } from 'http'
 
-  interface HttpContextContract extends BaseContextContract {
+  export interface HttpContextContract extends BaseContextContract {
     response: ResponseContract,
     request: RequestContract,
     logger: LoggerContract,
   }
+
+  export interface HttpContextConstructorContract {
+    create (
+      routePattern: string,
+      routeParams: any,
+      req?: IncomingMessage,
+      res?: ServerResponse,
+      serverConfig?: ServerConfig,
+    ): HttpContextContract
+  }
+
+  const HttpContext: HttpContextConstructorContract
+  export default HttpContext
 }
 
 /**

src/HttpContext/index.ts

@@ -13,10 +13,13 @@
 
 /// <reference path="../contracts.ts" />
 
-import { RouteNode, HttpContextContract } from '@poppinss/http-server/contracts'
-import { RequestContract } from '@poppinss/request'
-import { ResponseContract } from '@poppinss/response'
-import { LoggerContract } from '@poppinss/logger'
+import { Socket } from 'net'
+import { IncomingMessage, ServerResponse } from 'http'
+import { RequestContract, Request } from '@poppinss/request'
+import { LoggerContract, getLogger } from '@poppinss/logger'
+import { ResponseContract, Response } from '@poppinss/response'
+import { RouteNode, HttpContextContract, ServerConfig } from '@poppinss/http-server/contracts'
+import { makeUrl, getServerConfig } from '../helpers'
 
 /**
  * Http context is passed to all route handlers, middleware,
@@ -31,6 +34,75 @@ export class HttpContext implements HttpContextContract {
     public request: RequestContract,
     public response: ResponseContract,
     public logger: LoggerContract,
+  ) {}
+
+  /**
+   * Creates a new fake context instance for a given route.
+   */
+  public static create (
+    routePattern: string,
+    routeParams: any,
+    req?: IncomingMessage,
+    res?: ServerResponse,
+    serverConfig?: ServerConfig,
   ) {
+    req = req || new IncomingMessage(new Socket())
+    res = res || new ServerResponse(req)
+
+    /**
+     * Composing server config
+     */
+    serverConfig = getServerConfig(serverConfig || {})
+
+    /**
+     * Creating the url from the router pattern and params. Only
+     * when actual URL isn't defined.
+     */
+    req.url = req.url || makeUrl(routePattern, { params: routeParams })
+
+    /**
+     * Creating new request instance
+     */
+    const request = new Request(req, res, {
+      allowMethodSpoofing: serverConfig.allowMethodSpoofing,
+      subdomainOffset: serverConfig.subdomainOffset,
+      trustProxy: serverConfig.trustProxy,
+    })
+
+    /**
+     * Creating new response instance
+     */
+    const response = new Response(req, res, {
+      etag: serverConfig.etag,
+      cookie: serverConfig.cookie,
+      jsonpCallbackName: serverConfig.jsonpCallbackName,
+    })
+
+    /**
+     * Creating new ctx instance
+     */
+    const ctx = new HttpContext(request, response, getLogger({
+      name: 'adonis',
+      enabled: true,
+      level: 'trace',
+      messageKey: 'msg',
+    }))
+
+    /**
+     * Attaching route to the ctx
+     */
+    ctx.route = {
+      pattern: routePattern,
+      middleware: [],
+      handler: async () => 'handled',
+      meta: {},
+    }
+
+    /**
+     * Attaching params to the ctx
+     */
+    ctx.params = routeParams
+
+    return ctx
   }
 }

src/Router/index.ts

@@ -13,8 +13,6 @@
 
 /// <reference path="../contracts.ts" />
 
-import { stringify } from 'querystring'
-import { Exception } from '@poppinss/utils'
 import {
   RouteMatchers,
   RouteNode,
@@ -23,13 +21,14 @@ import {
   RouteLookupNode,
   RouteHandlerNode,
 } from '@poppinss/http-server/contracts'
+import { Exception } from '@poppinss/utils'
 
 import { Route } from './Route'
 import { RouteResource } from './Resource'
 import { RouteGroup } from './Group'
 import { BriskRoute } from './BriskRoute'
 import { Store } from './Store'
-import { toRoutesJSON, exceptionCodes } from '../helpers'
+import { toRoutesJSON, exceptionCodes, makeUrl } from '../helpers'
 
 /**
  * Router class exposes unified API to create new routes, group them or
@@ -359,47 +358,7 @@ export class Router<Context> implements RouterContract<Context> {
       return null
     }
 
-    let url = matchingRoute.pattern
-
-    if (url.indexOf(':') > -1) {
-      /**
-       * Split pattern when route has dynamic segments
-       */
-      const tokens = url.split('/')
-
-      /**
-       * Lookup over the route tokens and replace them the params values
-       */
-      url = tokens.map((token) => {
-        if (!token.startsWith(':')) {
-          return token
-        }
-
-        const isOptional = token.endsWith('?')
-        const paramName = token.replace(/^:/, '').replace(/\?$/, '')
-        const param = options.params[paramName]
-
-        /**
-         * A required param is always required to make the complete URL
-         */
-        if (!param && !isOptional) {
-          throw new Exception(
-            `\`${paramName}\` param is required to make URL for \`${matchingRoute.pattern}\` route`,
-            500,
-            exceptionCodes.E_MISSING_ROUTE_PARAM_VALUE,
-          )
-        }
-
-        return param
-      }).join('/')
-    }
-
-    /**
-     * Stringify query string and append to the URL (if exists)
-     */
-    const qs = stringify(options.qs)
-    url = qs ? `${url}?${qs}` : url
-
+    const url = makeUrl(matchingRoute.pattern, options)
     return matchingRoute.domain !== 'root' ? `//${matchingRoute.domain}${url}` : url
   }
 

src/helpers.ts

@@ -13,12 +13,15 @@
 
 /// <reference path="./contracts.ts" />
 
-import { RouteDefination } from '@poppinss/http-server/contracts'
+import { stringify } from 'querystring'
+import * as proxyAddr from 'proxy-addr'
+import { Exception } from '@poppinss/utils'
 
 import { Route } from './Router/Route'
-import { RouteResource } from './Router/Resource'
-import { BriskRoute } from './Router/BriskRoute'
 import { RouteGroup } from './Router/Group'
+import { BriskRoute } from './Router/BriskRoute'
+import { RouteResource } from './Router/Resource'
+import { RouteDefination, ServerConfig } from '@poppinss/http-server/contracts'
 
 /**
  * Makes input string consistent by having only the starting
@@ -65,6 +68,68 @@ export function toRoutesJSON<Context extends any> (
   }, [])
 }
 
+/**
+ * Makes url for a route pattern and params and querystring.
+ */
+export function makeUrl (pattern: string, options: { params?: any, qs?: any }): string {
+  let url = pattern
+
+  if (url.indexOf(':') > -1) {
+    /**
+     * Split pattern when route has dynamic segments
+     */
+    const tokens = url.split('/')
+
+    /**
+     * Lookup over the route tokens and replace them the params values
+     */
+    url = tokens.map((token) => {
+      if (!token.startsWith(':')) {
+        return token
+      }
+
+      const isOptional = token.endsWith('?')
+      const paramName = token.replace(/^:/, '').replace(/\?$/, '')
+      const param = options.params[paramName]
+
+      /**
+       * A required param is always required to make the complete URL
+       */
+      if (!param && !isOptional) {
+        throw new Exception(
+          `\`${paramName}\` param is required to make URL for \`${pattern}\` route`,
+          500,
+          exceptionCodes.E_MISSING_ROUTE_PARAM_VALUE,
+        )
+      }
+
+      return param
+    }).join('/')
+  }
+
+  /**
+   * Stringify query string and append to the URL (if exists)
+   */
+  const qs = stringify(options.qs)
+  return qs ? `${url}?${qs}` : url
+}
+
+/**
+ * Returns server config by merging the user options with the default
+ * options.
+ */
+export function getServerConfig (serverConfig: Partial<ServerConfig>): ServerConfig {
+  return Object.assign({
+    secret: Math.random().toFixed(36).substring(2, 38),
+    subdomainOffset: 2,
+    allowMethodSpoofing: true,
+    etag: false,
+    cookie: {},
+    jsonpCallbackName: 'callback',
+    trustProxy: proxyAddr.compile('loopback'),
+  }, serverConfig)
+}
+
 /**
  * Module wide exception codes
  */

test/http-context.spec.ts

@@ -0,0 +1,30 @@
+/*
+* @poppinss/http-server
+*
+* (c) Harminder Virk <[email protected]>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+import * as test from 'japa'
+import { HttpContext } from '../src/HttpContext'
+
+test.group('Http Context', () => {
+  test('create fake Http context instance', async (assert) => {
+    const ctx = HttpContext.create('/', {})
+
+    assert.instanceOf(ctx, HttpContext)
+    assert.equal(ctx.route!.pattern, '/')
+    assert.deepEqual(ctx.route!.middleware, [])
+  })
+
+  test('compute request url from params', async (assert) => {
+    const ctx = HttpContext.create('/:id', { id: '1' })
+
+    assert.instanceOf(ctx, HttpContext)
+    assert.equal(ctx.route!.pattern, '/:id')
+    assert.equal(ctx.request.url(), '/1')
+    assert.deepEqual(ctx.params, { id: '1' })
+  })
+})