test: simplify tests setup and add test for provider

Author: thetutlage

npm-audit.html

@@ -55,7 +55,7 @@ <h5 class="card-title">
                 <div class="card">
                     <div class="card-body">
                         <h5 class="card-title">
-                            July 22nd 2020, 9:46:15 am
+                            July 23rd 2020, 5:46:38 am
                         </h5>
                         <p class="card-text">Last updated</p>
                     </div>

package-lock.json

@@ -34,6 +34,8 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
+    "@adonisjs/application": "^2.0.0",
+    "@adonisjs/config": "^1.1.0",
     "@adonisjs/encryption": "^2.0.6",
     "@adonisjs/fold": "^6.3.5",
     "@adonisjs/logger": "^2.1.0",

package.json

@@ -9,70 +9,73 @@
 
 import { IocContract } from '@adonisjs/fold'
 
-import { Server } from '../src/Server'
-import { Request } from '../src/Request'
-import { Response } from '../src/Response'
-import { HttpContext } from '../src/HttpContext'
-import { MiddlewareStore } from '../src/MiddlewareStore'
-
 export default class HttpServerProvider {
-	constructor(protected $container: IocContract) {}
+	constructor(protected container: IocContract) {}
 
 	/**
 	 * Register request and response bindings to the container
 	 */
-	protected $registerRequestResponse() {
-		this.$container.bind('Adonis/Core/Request', () => Request)
-		this.$container.bind('Adonis/Core/Response', () => Response)
+	protected registerRequestResponse() {
+		this.container.singleton('Adonis/Core/Request', () => {
+			return require('../src/Request').Request
+		})
+
+		this.container.singleton('Adonis/Core/Response', () => {
+			return require('../src/Response').Response
+		})
 	}
 
 	/**
 	 * Registering middleware store to the container
 	 */
-	protected $registerMiddlewareStore() {
-		this.$container.bind('Adonis/Core/MiddlewareStore', () => MiddlewareStore)
+	protected registerMiddlewareStore() {
+		this.container.bind('Adonis/Core/MiddlewareStore', () => {
+			return require('../src/MiddlewareStore').MiddlewareStore
+		})
 	}
 
 	/**
 	 * Registering the HTTP context
 	 */
-	protected $registerHTTPContext() {
-		this.$container.bind('Adonis/Core/HttpContext', () => HttpContext)
+	protected registerHTTPContext() {
+		this.container.bind('Adonis/Core/HttpContext', () => {
+			return require('../src/HttpContext').HttpContext
+		})
 	}
 
 	/**
 	 * Register the HTTP server
 	 */
-	protected $registerHttpServer() {
-		this.$container.singleton('Adonis/Core/Server', () => {
-			const Logger = this.$container.use('Adonis/Core/Logger')
-			const Profiler = this.$container.use('Adonis/Core/Profiler')
-			const Config = this.$container.use('Adonis/Core/Config')
-			const Encryption = this.$container.use('Adonis/Core/Encryption')
+	protected registerHttpServer() {
+		this.container.singleton('Adonis/Core/Server', () => {
+			const { Server } = require('../src/Server')
 
-			const config = Object.assign({ secret: Config.get('app.appKey') }, Config.get('app.http', {}))
-			return new Server(this.$container, Logger, Profiler, Encryption, config)
+			const Logger = this.container.use('Adonis/Core/Logger')
+			const Profiler = this.container.use('Adonis/Core/Profiler')
+			const Config = this.container.use('Adonis/Core/Config')
+			const Encryption = this.container.use('Adonis/Core/Encryption')
+			return new Server(this.container, Logger, Profiler, Encryption, Config.get('app.http', {}))
 		})
 	}
 
 	/**
 	 * Register the router. The router points to the instance of router used
 	 * by the middleware
 	 */
-	protected $registerRouter() {
-		this.$container.singleton('Adonis/Core/Route', () => {
-			return this.$container.use('Adonis/Core/Server').router
+	protected registerRouter() {
+		this.container.singleton('Adonis/Core/Route', () => {
+			return this.container.use('Adonis/Core/Server').router
 		})
 	}
 
 	/**
 	 * Registering all bindings
 	 */
 	public register() {
-		this.$registerRequestResponse()
-		this.$registerMiddlewareStore()
-		this.$registerHttpServer()
-		this.$registerHTTPContext()
-		this.$registerRouter()
+		this.registerRequestResponse()
+		this.registerMiddlewareStore()
+		this.registerHttpServer()
+		this.registerHTTPContext()
+		this.registerRouter()
 	}
 }

providers/HttpServerProvider.ts

@@ -0,0 +1,49 @@
+/*
+ * @adonisjs/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 proxyaddr from 'proxy-addr'
+import { ServerConfig } from '@ioc:Adonis/Core/Server'
+import { RequestConfig } from '@ioc:Adonis/Core/Request'
+import { ResponseConfig } from '@ioc:Adonis/Core/Response'
+import { FakeLogger } from '@adonisjs/logger/build/standalone'
+import { Profiler } from '@adonisjs/profiler/build/standalone'
+import { Encryption } from '@adonisjs/encryption/build/standalone'
+
+export const appSecret = 'averylongrandom32charslongsecret'
+
+export const loggerConfig = {
+	name: 'http-server',
+	enabled: true,
+	level: 'debug',
+}
+
+export const requestConfig: RequestConfig = {
+	allowMethodSpoofing: false,
+	trustProxy: proxyaddr.compile('loopback'),
+	subdomainOffset: 2,
+	generateRequestId: true,
+}
+
+export const responseConfig: ResponseConfig = {
+	etag: false,
+	jsonpCallbackName: 'callback',
+	cookie: {
+		maxAge: 90,
+		path: '/',
+		httpOnly: true,
+		sameSite: false,
+		secure: false,
+	},
+}
+
+export const serverConfig: ServerConfig = Object.assign({}, requestConfig, responseConfig)
+
+export const logger = new FakeLogger(loggerConfig)
+export const profiler = new Profiler(__dirname, logger, { enabled: false })
+export const encryption = new Encryption({ secret: appSecret })

test-helpers/index.ts

@@ -8,13 +8,11 @@
  */
 
 import test from 'japa'
-import { Encryption } from '@adonisjs/encryption/build/standalone'
 
+import { encryption } from '../test-helpers'
 import { CookieParser } from '../src/Cookie/Parser'
 import { CookieSerializer } from '../src/Cookie/Serializer'
 
-const SECRET = Math.random().toFixed(36).substring(2, 38)
-const encryption = new Encryption({ secret: SECRET })
 const serializer = new CookieSerializer(encryption)
 
 test.group('Cookie | parse', () => {

test/cookie-parser.spec.ts

@@ -9,13 +9,10 @@
 
 import test from 'japa'
 import { base64, MessageBuilder } from '@poppinss/utils'
-import { Encryption } from '@adonisjs/encryption/build/standalone'
 
+import { encryption } from '../test-helpers'
 import { CookieSerializer } from '../src/Cookie/Serializer'
 
-const SECRET = Math.random().toFixed(36).substring(2, 38)
-const encryption = new Encryption({ secret: SECRET })
-
 test.group('Cookie | serialize', () => {
 	test('serialize and sign cookie', (assert) => {
 		const serializer = new CookieSerializer(encryption)

test/cookie-serializer.spec.ts

@@ -8,11 +8,9 @@
  */
 
 import test from 'japa'
-import { Encryption } from '@adonisjs/encryption/build/standalone'
-import { pack, unpack, canUnpack } from '../src/Cookie/Drivers/Encrypted'
 
-const SECRET = 'averylongradom32charactersstring'
-const encryption = new Encryption({ secret: SECRET })
+import { encryption } from '../test-helpers'
+import { pack, unpack, canUnpack } from '../src/Cookie/Drivers/Encrypted'
 
 test.group('EncryptedCookie | Pack', () => {
 	test('pack cookie as encrypted cookie', (assert) => {

test/encrypted-cookie.spec.ts

@@ -8,16 +8,14 @@
  */
 
 import test from 'japa'
-import { HttpContext as BaseHttpContext } from '../src/HttpContext'
-import { HttpContextConstructorContract } from '@ioc:Adonis/Core/HttpContext'
 import { Logger } from '@adonisjs/logger/build/standalone'
 import { Profiler } from '@adonisjs/profiler/build/standalone'
-import { Encryption } from '@adonisjs/encryption/build/standalone'
+import { HttpContextConstructorContract } from '@ioc:Adonis/Core/HttpContext'
+
+import { encryption } from '../test-helpers'
+import { HttpContext as BaseHttpContext } from '../src/HttpContext'
 
 const HttpContext = (BaseHttpContext as any) as HttpContextConstructorContract
-const encryption = new Encryption({
-	secret: 'averylongrandom32charslongsecret',
-})
 
 test.group('Http Context', () => {
 	test('create fake Http context instance', async (assert) => {

test/http-context.spec.ts

@@ -0,0 +1,63 @@
+/*
+ * @adonisjs/events
+ *
+ * (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 test from 'japa'
+import { join } from 'path'
+import { Registrar, Ioc } from '@adonisjs/fold'
+import { Config } from '@adonisjs/config/build/standalone'
+import { Application } from '@adonisjs/application/build/standalone'
+
+import { Router } from '../src/Router'
+import { Server } from '../src/Server'
+import { Request } from '../src/Request'
+import { Response } from '../src/Response'
+import { HttpContext } from '../src/HttpContext'
+import { MiddlewareStore } from '../src/MiddlewareStore'
+import { appSecret, serverConfig } from '../test-helpers'
+
+test.group('Http Server Provider', () => {
+	test('register http server provider', async (assert) => {
+		const ioc = new Ioc()
+		ioc.bind('Adonis/Core/Config', () => {
+			return new Config({
+				app: {
+					http: serverConfig,
+					appKey: appSecret,
+					logger: {
+						name: 'adonisjs',
+						level: 'info',
+						enabled: false,
+					},
+				},
+			})
+		})
+
+		ioc.bind('Adonis/Core/Application', () => {
+			return new Application(__dirname, ioc, {}, {})
+		})
+
+		const registrar = new Registrar(ioc, join(__dirname, '..'))
+
+		await registrar
+			.useProviders([
+				'@adonisjs/logger',
+				'@adonisjs/profiler',
+				'@adonisjs/encryption',
+				'./providers/HttpServerProvider',
+			])
+			.registerAndBoot()
+
+		assert.instanceOf(ioc.use('Adonis/Core/Route'), Router)
+		assert.deepEqual(ioc.use('Adonis/Core/Request'), Request)
+		assert.deepEqual(ioc.use('Adonis/Core/Response'), Response)
+		assert.instanceOf(ioc.use('Adonis/Core/Server'), Server)
+		assert.deepEqual(ioc.use('Adonis/Core/MiddlewareStore'), MiddlewareStore)
+		assert.deepEqual(ioc.use('Adonis/Core/HttpContext'), HttpContext)
+	})
+})