@athenna/http 3.2.1 → 3.4.0

package/build/Testing/Plugins/Request/TestResponse.js

@@ -0,0 +1,400 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export class TestResponse {
+    /**
+     * Japa assert class instance.
+     */
+    assert;
+    /**
+     * Light my request response object.
+     */
+    response;
+    constructor(assert, response) {
+        this.assert = assert;
+        this.response = response;
+    }
+    /**
+     * Assert the status code of the response.
+     *
+     * @example
+     * ```js
+     * response.assertStatusCode(200)
+     * ```
+     */
+    assertStatusCode(statusCode) {
+        this.assert.deepEqual(this.response.statusCode, statusCode);
+    }
+    /**
+     * Assert the status code is not the same of the response.
+     *
+     * @example
+     * ```js
+     * response.assertIsNotStatusCode(200)
+     * ```
+     */
+    assertIsNotStatusCode(statusCode) {
+        this.assert.notDeepEqual(this.response.statusCode, statusCode);
+    }
+    /**
+     * Assert body (array or object) to contain a subset of the expected value.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyContains({ id: 1 }) // passes
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyContains([{ id: 1 }, { id: 2 }]) // passes
+     * ```
+     */
+    assertBodyContains(values) {
+        this.assert.containsSubset(this.response.json(), values);
+    }
+    /**
+     * Assert body (array or object) to not contain a subset of the expected value.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotContains({ id: 1 }) // fails
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyNotContains([{ id: 3 }]) // passes
+     * ```
+     */
+    assertBodyNotContains(values) {
+        this.assert.notContainsSubset(this.response.json(), values);
+    }
+    /**
+     * Assert body to contain a key.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyContainsKey('id') // passes
+     * ```
+     */
+    assertBodyContainsKey(key) {
+        this.assert.property(this.response.json(), key);
+    }
+    /**
+     * Assert body to not contain a key.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotContainsKey('id') // fails
+     * ```
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotContainsKey('createdAt') // passes
+     * ```
+     */
+    assertBodyNotContainsKey(key) {
+        this.assert.notProperty(this.response.json(), key);
+    }
+    /**
+     * Assert body to contain all keys.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyContainsAllKeys(['id', 'post']) // passes
+     * ```
+     */
+    assertBodyContainsAllKeys(keys) {
+        this.assert.properties(this.response.json(), keys);
+    }
+    /**
+     * Assert body to not contain all keys.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotContainsAllKeys(['id']) // fails
+     * ```
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotContainsAllKeys(['createdAt']) // passes
+     * ```
+     */
+    assertBodyNotContainsAllKeys(keys) {
+        this.assert.notAllProperties(this.response.json(), keys);
+    }
+    /**
+     * Assert body (array or object) to be deep equal to the expected value.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyDeepEqual({ id: 1 }) // fails
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyDeepEqual([{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]) // passes
+     * ```
+     */
+    assertBodyDeepEqual(values) {
+        this.assert.deepEqual(this.response.json(), values);
+    }
+    /**
+     * Assert body (array or object) to be not deep equal to the expected value.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyNotDeepEqual({ id: 1 }) // passes
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyNotDeepEqual([{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]) // fails
+     * ```
+     */
+    assertBodyNotDeepEqual(values) {
+        this.assert.notDeepEqual(this.response.json(), values);
+    }
+    /**
+     * Assert body to be an array.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyIsArray() // fails
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyIsArray() // passes
+     * ```
+     */
+    assertBodyIsArray() {
+        this.assert.isArray(this.response.json());
+    }
+    /**
+     * Assert body to not be an array.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyIsNotArray() // passes
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyIsNotArray() // fails
+     * ```
+     */
+    assertBodyIsNotArray() {
+        this.assert.isNotArray(this.response.json());
+    }
+    /**
+     * Assert body to be an object.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyIsObject() // passes
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyIsObject() // fails
+     * ```
+     */
+    assertBodyIsObject() {
+        this.assert.isObject(this.response.json());
+    }
+    /**
+     * Assert body to not be an object.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertBodyIsNotObject() // fails
+     * ```
+     * @example
+     * ```js
+     * const body = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertBodyIsNotObject() // passes
+     * ```
+     */
+    assertBodyIsNotObject() {
+        this.assert.isNotObject(this.response.json());
+    }
+    /**
+     * Assert header (array or object) to contain a subset of the expected value.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderContains({ id: 1 }) // passes
+     * ```
+     * @example
+     * ```js
+     * const header = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     *  response.assertHeaderContains([{ id: 1 }, { id: 2 }]) // passes
+     * ```
+     */
+    assertHeaderContains(values) {
+        this.assert.containsSubset(this.response.headers, values);
+    }
+    /**
+     * Assert header (array or object) to not contain a subset of the expected value.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderContains({ id: 1 }) // passes
+     * ```
+     * @example
+     * ```js
+     * const header = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertHeaderContains([{ id: 1 }, { id: 2 }]) // passes
+     * ```
+     */
+    assertHeaderNotContains(values) {
+        this.assert.notContainsSubset(this.response.headers, values);
+    }
+    /**
+     * Assert header (array or object) to be deep equal to the expected value.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderDeepEqual({ id: 1 }) // fails
+     * ```
+     * @example
+     * ```js
+     * const header = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertHeaderDeepEqual([{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]) // passes
+     * ```
+     */
+    assertHeaderDeepEqual(values) {
+        this.assert.deepEqual(this.response.headers, values);
+    }
+    /**
+     * Assert header (array or object) to be not deep equal to the expected value.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderNotDeepEqual({ id: 1 }) // passes
+     * ```
+     * @example
+     * ```js
+     * const header = [{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]
+     *
+     * response.assertHeaderNotDeepEqual([{ id: 1, name: 'post 1' }, { id: 2, name: 'post 2'}]) // fails
+     * ```
+     */
+    assertHeaderNotDeepEqual(values) {
+        this.assert.notDeepEqual(this.response.headers, values);
+    }
+    /**
+     * Assert header to contain a key.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderContainsKey('id') // passes
+     * ```
+     */
+    assertHeaderContainsKey(key) {
+        this.assert.property(this.response.headers, key);
+    }
+    /**
+     * Assert header to not contain a key.
+     *
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderNotContainsKey('id') // fails
+     * ```
+     * @example
+     * ```js
+     * const body = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderNotContainsKey('createdAt') // passes
+     * ```
+     */
+    assertHeaderNotContainsKey(key) {
+        this.assert.notProperty(this.response.headers, key);
+    }
+    /**
+     * Assert header to contain all keys.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderContainsAllKeys(['id', 'post']) // passes
+     * ```
+     */
+    assertHeaderContainsAllKeys(keys) {
+        this.assert.properties(this.response.headers, keys);
+    }
+    /**
+     * Assert header to not contain all keys.
+     *
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderNotContainsAllKeys(['id']) // fails
+     * ```
+     * @example
+     * ```js
+     * const header = { id: 1, name: 'post 1' }
+     *
+     * response.assertHeaderNotContainsAllKeys(['createdAt']) // passes
+     * ```
+     */
+    assertHeaderNotContainsAllKeys(keys) {
+        this.assert.notAllProperties(this.response.headers, keys);
+    }
+}

package/build/Testing/Plugins/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { TestRequest } from './Request/TestRequest.js';
+declare module '@japa/runner' {
+    interface TestContext {
+        request: TestRequest;
+    }
+}
+export * from './Request/TestRequest.js';
+export * from './Request/TestResponse.js';
+/**
+ * Request plugin register the request macro to the test context.
+ */
+export declare function request(): (_config: any, _runner: any, classes: any) => Promise<void>;

package/build/Testing/Plugins/index.js

@@ -0,0 +1,19 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { TestRequest } from './Request/TestRequest.js';
+export * from './Request/TestRequest.js';
+export * from './Request/TestResponse.js';
+/**
+ * Request plugin register the request macro to the test context.
+ */
+export function request() {
+    return async function (_config, _runner, classes) {
+        classes.TestContext.macro('request', new TestRequest());
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "The Athenna Http server. Built on top of fastify.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -45,6 +45,7 @@
   "types": "./build/index.d.ts",
   "exports": {
     ".": "./build/index.js",
+    "./testing/plugins": "./build/Testing/Plugins/index.js",
     "./providers/HttpRouteProvider": "./build/Providers/HttpRouteProvider.js",
     "./providers/HttpServerProvider": "./build/Providers/HttpServerProvider.js",
     "./commands/RouteListCommand": "./build/Commands/RouteListCommand.js",
@@ -63,8 +64,8 @@
     "fastify": "^4.13.0"
   },
   "devDependencies": {
-    "@athenna/artisan": "^3.2.0",
-    "@athenna/common": "^3.3.1",
+    "@athenna/artisan": "^3.3.0",
+    "@athenna/common": "^3.3.3",
     "@athenna/config": "^3.2.0",
     "@athenna/ioc": "^3.1.5",
     "@athenna/logger": "^3.1.5",
@@ -125,7 +126,8 @@
     "exclude": [
       "src/Types/*",
       "src/Contracts/*",
-      "src/Exceptions/*"
+      "src/Exceptions/*",
+      "src/Commands/*"
     ],
     "reporter": [
       "text-summary",
@@ -262,7 +264,11 @@
       "#tests/Stubs/middlewares/DecoratedGlobalTerminator"
     ],
     "commandsManifest": {
-      "route:list": "#src/Commands/RouteListCommand",
+      "route:list": {
+        "path": "#src/Commands/RouteListCommand",
+        "route": "./tests/Stubs/routes/http.js",
+        "kernel": "./tests/Stubs/kernels/HttpKernel.js"
+      },
       "make:controller": "#src/Commands/MakeControllerCommand",
       "make:interceptor": "#src/Commands/MakeInterceptorCommand",
       "make:middleware": "#src/Commands/MakeMiddlewareCommand",