From 6b4b6d54f3501c76f8c0577a57846f243fc987f5 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 17:43:59 +0300
Subject: [PATCH 01/14] feat: allow to set custom http client adapter

---
 src/config.js                     | 17 +++++++
 src/http-clients/adapter.d.ts     | 39 --------------
 src/http-clients/adapter.js       | 85 +++++++++++++++++++++++++++++++
 src/http-clients/axios-adapter.js | 16 ++----
 src/http-clients/defaults.js      | 31 +++++++++++
 src/http-clients/index.js         |  7 +++
 src/index.js                      |  6 ++-
 types/index.d.ts                  | 47 ++++++++++++++++-
 8 files changed, 196 insertions(+), 52 deletions(-)
 create mode 100644 src/config.js
 delete mode 100644 src/http-clients/adapter.d.ts
 create mode 100644 src/http-clients/adapter.js
 create mode 100644 src/http-clients/defaults.js

diff --git a/src/config.js b/src/config.js
new file mode 100644
index 0000000..85f9df0
--- /dev/null
+++ b/src/config.js
@@ -0,0 +1,17 @@
+const { setDefaultAdapter } = require('./http-clients/defaults');
+
+/**
+ *
+ * @param {{defaultAdapter?: typeof HttpClientAdapter}} options
+ */
+function configure(options = {}) {
+  if (!options) {
+    return;
+  }
+
+  if (options.defaultAdapter) {
+    setDefaultAdapter(options.defaultAdapter);
+  }
+}
+
+module.exports = { configure };
diff --git a/src/http-clients/adapter.d.ts b/src/http-clients/adapter.d.ts
deleted file mode 100644
index 521d98f..0000000
--- a/src/http-clients/adapter.d.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-export type CanAdapterHandle = 'no' | 'yes' | 'maybe';
-
-export abstract class HttpClientAdapter<Response> {
-  /**
-   * The name of the client the adapter
-   *
-   * @example axios
-   */
-  public static name: string;
-
-  protected constructor(response: Response);
-
-  /**
-   * Test whether this response can be handled by this adapter
-   */
-  public static canHandle(response: any): CanAdapterHandle;
-
-  /**
-   * Get the url of the request, **this may be called multiple times**
-   */
-  public getUrl(): string;
-
-  /**
-   * Get the status code of the response, **this may be called multiple times**
-   */
-  public getStatusCode(): number;
-
-  /**
-   * Get the headers of the response, **this may be called multiple times**
-   */
-  public getHeaders(): Record<string, string>;
-
-  /**
-   * Get the body of the response, **this may be called multiple times**
-   */
-  public getBody(): unknown;
-}
-
-export type UnknownHttpClientAdapter = typeof HttpClientAdapter<any>;
diff --git a/src/http-clients/adapter.js b/src/http-clients/adapter.js
new file mode 100644
index 0000000..2cf1a82
--- /dev/null
+++ b/src/http-clients/adapter.js
@@ -0,0 +1,85 @@
+// When you update here, please also update the index.d.ts in types folder
+
+/**
+ *
+ * HTTP Client Adapter
+ * @abstract
+ */
+class HttpClientAdapter {
+    /**
+     * The name of the client the adapter
+     *
+     * @type {string}
+     * @example axios
+     * @abstract
+     */
+    static name;
+
+    /**
+     * The response object
+     * @type {unknown}
+     */
+    response;
+
+    /**
+     *
+     * @param response
+     * @protected
+     */
+    constructor(response) {
+        this.response = response;
+    }
+
+    /**
+     * Test whether this response can be handled by this adapter
+     *
+     * @param {unknown} response
+     * @returns {'yes' | 'no' | 'maybe'}
+     * @abstract
+     */
+    static canHandle(response) {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Get the url of the request, **this may be called multiple times**
+     *
+     * @returns {string}
+     * @abstract
+     */
+    getUrl() {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Get the status code of the response, **this may be called multiple times**
+     *
+     * @returns {number}
+     * @abstract
+     *
+     */
+    getStatusCode() {
+       throw new Error('Not implemented');
+    }
+
+    /**
+     * Get the headers of the response, **this may be called multiple times**
+     * @return {Record<string, string>}
+     * @abstract
+     */
+    getHeaders() {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Get the body of the response, **this may be called multiple times**
+     *
+     * @returns {unknown}
+     * @abstract
+     */
+    getBody() {
+        throw new Error('Not implemented');
+    }
+}
+
+module.exports = HttpClientAdapter;
diff --git a/src/http-clients/axios-adapter.js b/src/http-clients/axios-adapter.js
index ee0a778..ab01dcb 100644
--- a/src/http-clients/axios-adapter.js
+++ b/src/http-clients/axios-adapter.js
@@ -1,21 +1,15 @@
+const {HttpClientAdapter} = require("./adapter");
+
 /**
  * @typedef {import('axios').AxiosResponse} AxiosResponse
  */
 
-/**
- *
- * @type {UnknownHttpClientAdapter}
- */
-class AxiosHttpClientAdapter {
+class AxiosHttpClientAdapter extends HttpClientAdapter {
   /**
-   * @type {AxiosResponse}
+   * @param {AxiosResponse} response
    */
-  response;
-
-  httpClientName = 'axios';
-
   constructor(response) {
-    this.response = response;
+    super(response);
   }
 
   /**
diff --git a/src/http-clients/defaults.js b/src/http-clients/defaults.js
new file mode 100644
index 0000000..a15b227
--- /dev/null
+++ b/src/http-clients/defaults.js
@@ -0,0 +1,31 @@
+/**
+ *
+ * @type {typeof HttpClientAdapter}
+ */
+let DefaultAdapter;
+
+function hasDefaultAdapterConfigured() {
+  return DefaultAdapter !== undefined;
+}
+
+/**
+ *
+ * @returns {HttpClientAdapter}
+ */
+function getDefaultAdapter() {
+  return DefaultAdapter;
+}
+
+/**
+ *
+ * @param {typeof HttpClientAdapter} adapter
+ */
+function setDefaultAdapter(adapter) {
+  DefaultAdapter = adapter;
+}
+
+module.exports = {
+  hasDefaultAdapterConfigured,
+  getDefaultAdapter,
+  setDefaultAdapter,
+};
diff --git a/src/http-clients/index.js b/src/http-clients/index.js
index 9bf1ffc..9eeedbb 100644
--- a/src/http-clients/index.js
+++ b/src/http-clients/index.js
@@ -1,4 +1,5 @@
 const { AxiosHttpClientAdapter } = require('./axios-adapter');
+const { hasDefaultAdapterConfigured, getDefaultAdapter } = require('./defaults');
 
 /**
  *
@@ -12,6 +13,12 @@ const adapters = [AxiosHttpClientAdapter];
  * @return {HttpClientAdapter}
  */
 function getMatchingAdapter(response) {
+  if (hasDefaultAdapterConfigured()) {
+    const DefaultAdapter = getDefaultAdapter();
+
+    return new DefaultAdapter(response);
+  }
+
   const MatchingAdapter = adapters.find((adapter) => adapter.canHandle(response) === 'yes');
 
   if (MatchingAdapter) {
diff --git a/src/index.js b/src/index.js
index 923b190..4e75500 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,5 +1,9 @@
 const matchers = require('./matchers');
+const {configure} = require("./config");
+const {HttpClientAdapter} = require("./http-clients/adapter");
 
 module.exports = {
-  matchers,
+    matchers,
+    configure,
+    HttpClientAdapter
 };
diff --git a/types/index.d.ts b/types/index.d.ts
index b2a985c..afd9e80 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1,3 +1,48 @@
 declare module 'expect-http-client-matchers' {
-  export const matchers: import('./shared').CustomMatchers<any>;
+    export const matchers: import('./shared').CustomMatchers<any>;
+
+    export function configure(options?: { defaultAdapter?: typeof HttpClientAdapter }): void;
+
+    export type CanAdapterHandle = 'no' | 'yes' | 'maybe';
+    export abstract class HttpClientAdapter<Response> {
+        /**
+         * The name of the client the adapter
+         *
+         * @example axios
+         */
+        public static name: string;
+
+        /**
+         * The current response
+         * @protected
+         */
+        protected response: Response;
+
+        protected constructor(response: Response);
+
+        /**
+         * Test whether this response can be handled by this adapter
+         */
+        public static canHandle(response: any): CanAdapterHandle;
+
+        /**
+         * Get the url of the request, **this may be called multiple times**
+         */
+        public abstract getUrl(): string;
+
+        /**
+         * Get the status code of the response, **this may be called multiple times**
+         */
+        public abstract getStatusCode(): number;
+
+        /**
+         * Get the headers of the response, **this may be called multiple times**
+         */
+        public abstract getHeaders(): Record<string, string>;
+
+        /**
+         * Get the body of the response, **this may be called multiple times**
+         */
+        public abstract getBody(): unknown;
+    }
 }

From b8f02dbb75172342913fa880ae5005f5e609ee41 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 17:53:01 +0300
Subject: [PATCH 02/14] feat: allow to set default http client adapter

---
 src/config.js                     |  12 ++-
 src/http-clients/adapter.js       | 134 +++++++++++++++---------------
 src/http-clients/axios-adapter.js |   2 +-
 src/http-clients/defaults.js      |  31 -------
 src/http-clients/index.js         |  37 +++++++--
 src/index.js                      |  10 +--
 types/index.d.ts                  |  97 +++++++++++----------
 7 files changed, 164 insertions(+), 159 deletions(-)
 delete mode 100644 src/http-clients/defaults.js

diff --git a/src/config.js b/src/config.js
index 85f9df0..8128a11 100644
--- a/src/config.js
+++ b/src/config.js
@@ -1,16 +1,20 @@
-const { setDefaultAdapter } = require('./http-clients/defaults');
+const { addSupportedAdapters, setDefaultAdapterName } = require('./http-clients');
 
 /**
  *
- * @param {{defaultAdapter?: typeof HttpClientAdapter}} options
+ * @param {{ customAdapters?: (typeof HttpClientAdapter)[], defaultAdapterName?: string }} options
  */
 function configure(options = {}) {
   if (!options) {
     return;
   }
 
-  if (options.defaultAdapter) {
-    setDefaultAdapter(options.defaultAdapter);
+  if (options.customAdapters) {
+    addSupportedAdapters(options.customAdapters || []);
+  }
+
+  if (options.defaultAdapterName) {
+    setDefaultAdapterName(options.defaultAdapterName);
   }
 }
 
diff --git a/src/http-clients/adapter.js b/src/http-clients/adapter.js
index 2cf1a82..a890795 100644
--- a/src/http-clients/adapter.js
+++ b/src/http-clients/adapter.js
@@ -6,80 +6,80 @@
  * @abstract
  */
 class HttpClientAdapter {
-    /**
-     * The name of the client the adapter
-     *
-     * @type {string}
-     * @example axios
-     * @abstract
-     */
-    static name;
+  /**
+   * The name of the client the adapter
+   *
+   * @type {string}
+   * @example axios
+   * @abstract
+   */
+  static name;
 
-    /**
-     * The response object
-     * @type {unknown}
-     */
-    response;
+  /**
+   * The response object
+   * @type {unknown}
+   */
+  response;
 
-    /**
-     *
-     * @param response
-     * @protected
-     */
-    constructor(response) {
-        this.response = response;
-    }
+  /**
+   *
+   * @param response
+   * @protected
+   */
+  constructor(response) {
+    this.response = response;
+  }
 
-    /**
-     * Test whether this response can be handled by this adapter
-     *
-     * @param {unknown} response
-     * @returns {'yes' | 'no' | 'maybe'}
-     * @abstract
-     */
-    static canHandle(response) {
-        throw new Error('Not implemented');
-    }
+  /**
+   * Test whether this response can be handled by this adapter
+   *
+   * @param {unknown} response
+   * @returns {'yes' | 'no' | 'maybe'}
+   * @abstract
+   */
+  static canHandle(response) {
+    throw new Error('Not implemented');
+  }
 
-    /**
-     * Get the url of the request, **this may be called multiple times**
-     *
-     * @returns {string}
-     * @abstract
-     */
-    getUrl() {
-        throw new Error('Not implemented');
-    }
+  /**
+   * Get the url of the request, **this may be called multiple times**
+   *
+   * @returns {string}
+   * @abstract
+   */
+  getUrl() {
+    throw new Error('Not implemented');
+  }
 
-    /**
-     * Get the status code of the response, **this may be called multiple times**
-     *
-     * @returns {number}
-     * @abstract
-     *
-     */
-    getStatusCode() {
-       throw new Error('Not implemented');
-    }
+  /**
+   * Get the status code of the response, **this may be called multiple times**
+   *
+   * @returns {number}
+   * @abstract
+   *
+   */
+  getStatusCode() {
+    throw new Error('Not implemented');
+  }
 
-    /**
-     * Get the headers of the response, **this may be called multiple times**
-     * @return {Record<string, string>}
-     * @abstract
-     */
-    getHeaders() {
-        throw new Error('Not implemented');
-    }
+  /**
+   * Get the headers of the response, **this may be called multiple times**
+   * @return {Record<string, string>}
+   * @abstract
+   */
+  getHeaders() {
+    throw new Error('Not implemented');
+  }
 
-    /**
-     * Get the body of the response, **this may be called multiple times**
-     *
-     * @returns {unknown}
-     * @abstract
-     */
-    getBody() {
-        throw new Error('Not implemented');
-    }
+  /**
+   * Get the body of the response, **this may be called multiple times**
+   *
+   * @returns {unknown}
+   * @abstract
+   */
+  getBody() {
+    throw new Error('Not implemented');
+  }
 }
 
 module.exports = HttpClientAdapter;
diff --git a/src/http-clients/axios-adapter.js b/src/http-clients/axios-adapter.js
index ab01dcb..9aa9134 100644
--- a/src/http-clients/axios-adapter.js
+++ b/src/http-clients/axios-adapter.js
@@ -1,4 +1,4 @@
-const {HttpClientAdapter} = require("./adapter");
+const { HttpClientAdapter } = require('./adapter');
 
 /**
  * @typedef {import('axios').AxiosResponse} AxiosResponse
diff --git a/src/http-clients/defaults.js b/src/http-clients/defaults.js
deleted file mode 100644
index a15b227..0000000
--- a/src/http-clients/defaults.js
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- *
- * @type {typeof HttpClientAdapter}
- */
-let DefaultAdapter;
-
-function hasDefaultAdapterConfigured() {
-  return DefaultAdapter !== undefined;
-}
-
-/**
- *
- * @returns {HttpClientAdapter}
- */
-function getDefaultAdapter() {
-  return DefaultAdapter;
-}
-
-/**
- *
- * @param {typeof HttpClientAdapter} adapter
- */
-function setDefaultAdapter(adapter) {
-  DefaultAdapter = adapter;
-}
-
-module.exports = {
-  hasDefaultAdapterConfigured,
-  getDefaultAdapter,
-  setDefaultAdapter,
-};
diff --git a/src/http-clients/index.js b/src/http-clients/index.js
index 9eeedbb..010f6e5 100644
--- a/src/http-clients/index.js
+++ b/src/http-clients/index.js
@@ -1,11 +1,38 @@
 const { AxiosHttpClientAdapter } = require('./axios-adapter');
-const { hasDefaultAdapterConfigured, getDefaultAdapter } = require('./defaults');
 
 /**
  *
  * @type {(typeof HttpClientAdapter)[]}
  */
-const adapters = [AxiosHttpClientAdapter];
+let adapters = [AxiosHttpClientAdapter];
+
+/**
+ *
+ * @type {typeof HttpClientAdapter}
+ */
+let DefaultAdapter;
+
+/**
+ *
+ * @param {(typeof HttpClientAdapter)[]} customAdapters
+ */
+function addSupportedAdapters(customAdapters) {
+  adapters = [...new Set([...adapters, ...customAdapters]).keys()];
+}
+
+/**
+ *
+ * @param {string} adapterName
+ */
+function setDefaultAdapterName(adapterName) {
+  const adapterFound = adapters.find((adapter) => adapter.name === adapterName);
+
+  if (!adapterFound) {
+    throw new Error(`Adapter with name ${adapterName} not found`);
+  }
+
+  DefaultAdapter = adapterFound;
+}
 
 /**
  *
@@ -13,9 +40,7 @@ const adapters = [AxiosHttpClientAdapter];
  * @return {HttpClientAdapter}
  */
 function getMatchingAdapter(response) {
-  if (hasDefaultAdapterConfigured()) {
-    const DefaultAdapter = getDefaultAdapter();
-
+  if (DefaultAdapter) {
     return new DefaultAdapter(response);
   }
 
@@ -42,4 +67,6 @@ function getMatchingAdapter(response) {
 
 module.exports = {
   getMatchingAdapter,
+  addSupportedAdapters,
+  setDefaultAdapterName,
 };
diff --git a/src/index.js b/src/index.js
index 4e75500..5483c09 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,9 +1,9 @@
 const matchers = require('./matchers');
-const {configure} = require("./config");
-const {HttpClientAdapter} = require("./http-clients/adapter");
+const { configure } = require('./config');
+const { HttpClientAdapter } = require('./http-clients/adapter');
 
 module.exports = {
-    matchers,
-    configure,
-    HttpClientAdapter
+  matchers,
+  configure,
+  HttpClientAdapter,
 };
diff --git a/types/index.d.ts b/types/index.d.ts
index afd9e80..388bf8a 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1,48 +1,53 @@
 declare module 'expect-http-client-matchers' {
-    export const matchers: import('./shared').CustomMatchers<any>;
-
-    export function configure(options?: { defaultAdapter?: typeof HttpClientAdapter }): void;
-
-    export type CanAdapterHandle = 'no' | 'yes' | 'maybe';
-    export abstract class HttpClientAdapter<Response> {
-        /**
-         * The name of the client the adapter
-         *
-         * @example axios
-         */
-        public static name: string;
-
-        /**
-         * The current response
-         * @protected
-         */
-        protected response: Response;
-
-        protected constructor(response: Response);
-
-        /**
-         * Test whether this response can be handled by this adapter
-         */
-        public static canHandle(response: any): CanAdapterHandle;
-
-        /**
-         * Get the url of the request, **this may be called multiple times**
-         */
-        public abstract getUrl(): string;
-
-        /**
-         * Get the status code of the response, **this may be called multiple times**
-         */
-        public abstract getStatusCode(): number;
-
-        /**
-         * Get the headers of the response, **this may be called multiple times**
-         */
-        public abstract getHeaders(): Record<string, string>;
-
-        /**
-         * Get the body of the response, **this may be called multiple times**
-         */
-        public abstract getBody(): unknown;
-    }
+  export const matchers: import('./shared').CustomMatchers<any>;
+
+  export interface ConfigureOptions {
+    customAdapters?: (typeof HttpClientAdapter)[];
+    defaultAdapterName?: string;
+  }
+
+  export function configure(options?: ConfigureOptions): void;
+
+  export type CanAdapterHandle = 'no' | 'yes' | 'maybe';
+  export abstract class HttpClientAdapter<Response> {
+    /**
+     * The name of the client the adapter
+     *
+     * @example axios
+     */
+    public static name: string;
+
+    /**
+     * The current response
+     * @protected
+     */
+    protected response: Response;
+
+    protected constructor(response: Response);
+
+    /**
+     * Test whether this response can be handled by this adapter
+     */
+    public static canHandle(response: any): CanAdapterHandle;
+
+    /**
+     * Get the url of the request, **this may be called multiple times**
+     */
+    public abstract getUrl(): string;
+
+    /**
+     * Get the status code of the response, **this may be called multiple times**
+     */
+    public abstract getStatusCode(): number;
+
+    /**
+     * Get the headers of the response, **this may be called multiple times**
+     */
+    public abstract getHeaders(): Record<string, string>;
+
+    /**
+     * Get the body of the response, **this may be called multiple times**
+     */
+    public abstract getBody(): unknown;
+  }
 }

From 552cf7e1f5c2ebcce1debcac4a69469aeb54c077 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:18:18 +0300
Subject: [PATCH 03/14] feat: add got client support

---
 package.json                                  |  1 +
 src/http-clients/adapter.js                   |  7 ++-
 src/http-clients/got-adapter.js               | 49 +++++++++++++++
 src/http-clients/index.js                     |  3 +-
 .../helpers/supported-clients/got-adapter.mjs | 62 +++++++++++++++++++
 test/helpers/supported-clients/index.js       |  3 +-
 6 files changed, 120 insertions(+), 5 deletions(-)
 create mode 100644 src/http-clients/got-adapter.js
 create mode 100644 test/helpers/supported-clients/got-adapter.mjs

diff --git a/package.json b/package.json
index 639f314..a6ffc0c 100644
--- a/package.json
+++ b/package.json
@@ -31,6 +31,7 @@
     "concurrently": "^8.2.2",
     "expect": "^29.7.0",
     "fastify": "^4.28.1",
+    "got": "^14.4.2",
     "husky": "^8.0.3",
     "pretty-ansi": "^2.0.0",
     "semantic-release": "^19.0.5"
diff --git a/src/http-clients/adapter.js b/src/http-clients/adapter.js
index a890795..e301337 100644
--- a/src/http-clients/adapter.js
+++ b/src/http-clients/adapter.js
@@ -4,6 +4,7 @@
  *
  * HTTP Client Adapter
  * @abstract
+ * @template HttpClientResponse
  */
 class HttpClientAdapter {
   /**
@@ -17,13 +18,13 @@ class HttpClientAdapter {
 
   /**
    * The response object
-   * @type {unknown}
+   * @type {HttpClientResponse}
    */
   response;
 
   /**
    *
-   * @param response
+   * @param {HttpClientResponse} response
    * @protected
    */
   constructor(response) {
@@ -82,4 +83,4 @@ class HttpClientAdapter {
   }
 }
 
-module.exports = HttpClientAdapter;
+module.exports = {HttpClientAdapter};
diff --git a/src/http-clients/got-adapter.js b/src/http-clients/got-adapter.js
new file mode 100644
index 0000000..8016fa6
--- /dev/null
+++ b/src/http-clients/got-adapter.js
@@ -0,0 +1,49 @@
+const { HttpClientAdapter } = require('./adapter');
+
+/**
+ * @typedef {import('got').Response} GotResponse
+ */
+
+/**
+ * @extends {HttpClientAdapter<GotResponse>}
+ */
+class GotHttpClientAdapter extends HttpClientAdapter {
+  name = 'got';
+
+  /**
+   * @param {GotResponse} response
+   */
+  constructor(response) {
+    super(response);
+  }
+
+  getUrl() {
+    return this.response.url;
+  }
+
+  /**
+   *
+   * @param response
+   * @return {CanAdapterHandle}
+   */
+  static canHandle(response) {
+    if(response.timings) {
+      return 'maybe'
+    }
+
+    return 'no';
+  }
+
+  getStatusCode() {
+    return this.response.statusCode;
+  }
+
+  getHeaders() {
+    return this.response.headers;
+  }
+
+  getBody() {
+    return this.response.rawBody;
+  }
+}
+module.exports = { GotHttpClientAdapter };
diff --git a/src/http-clients/index.js b/src/http-clients/index.js
index 010f6e5..cd6ce49 100644
--- a/src/http-clients/index.js
+++ b/src/http-clients/index.js
@@ -1,10 +1,11 @@
 const { AxiosHttpClientAdapter } = require('./axios-adapter');
+const { GotHttpClientAdapter } = require('./got-adapter');
 
 /**
  *
  * @type {(typeof HttpClientAdapter)[]}
  */
-let adapters = [AxiosHttpClientAdapter];
+let adapters = [AxiosHttpClientAdapter, GotHttpClientAdapter];
 
 /**
  *
diff --git a/test/helpers/supported-clients/got-adapter.mjs b/test/helpers/supported-clients/got-adapter.mjs
new file mode 100644
index 0000000..11fb30b
--- /dev/null
+++ b/test/helpers/supported-clients/got-adapter.mjs
@@ -0,0 +1,62 @@
+import got from "got";
+
+const gotTestAdapterClient = {
+  name: 'axios',
+  request(url, config) {
+    return got.request({
+      url,
+      body: config.data,
+      method: config.method.toUpperCase(),
+      headers: config.headers,
+      searchParams: config.params,
+    });
+  },
+  get(url, config) {
+    return got.get(url, {
+      body: config?.data,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  delete(url, config) {
+    return got.delete(url, {
+      body: config?.data,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  head(url, config) {
+    return got.head(url, {
+      body: config?.data,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  options(url, config) {
+    return got.options(url, {
+      body: config?.data,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  post(url, data, config) {
+    return got.post(url, data, {
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  put(url, data, config) {
+    return got.put(url, data, {
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  patch(url, data, config) {
+    return got.patch(url, data, {
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+};
+
+export {gotTestAdapterClient}
diff --git a/test/helpers/supported-clients/index.js b/test/helpers/supported-clients/index.js
index 8af248f..87b4dc0 100644
--- a/test/helpers/supported-clients/index.js
+++ b/test/helpers/supported-clients/index.js
@@ -1,9 +1,10 @@
 const { axiosTestAdapterClient } = require('./axios-adapter');
+const {gotTestAdapterClient} = require("./got-adapter.mjs");
 
 /**
  * @type {TestAdapterClient[]}
  */
-const testClients = [axiosTestAdapterClient];
+const testClients = [axiosTestAdapterClient, gotTestAdapterClient];
 
 module.exports = {
   testClients,

From badbff66e98b6138a5a6295f198493674e5df24b Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:18:27 +0300
Subject: [PATCH 04/14] feat: add got client support

---
 src/http-clients/adapter.js                    | 2 +-
 src/http-clients/got-adapter.js                | 4 ++--
 test/helpers/supported-clients/got-adapter.mjs | 4 ++--
 test/helpers/supported-clients/index.js        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/http-clients/adapter.js b/src/http-clients/adapter.js
index e301337..3368a10 100644
--- a/src/http-clients/adapter.js
+++ b/src/http-clients/adapter.js
@@ -83,4 +83,4 @@ class HttpClientAdapter {
   }
 }
 
-module.exports = {HttpClientAdapter};
+module.exports = { HttpClientAdapter };
diff --git a/src/http-clients/got-adapter.js b/src/http-clients/got-adapter.js
index 8016fa6..1b0da44 100644
--- a/src/http-clients/got-adapter.js
+++ b/src/http-clients/got-adapter.js
@@ -27,8 +27,8 @@ class GotHttpClientAdapter extends HttpClientAdapter {
    * @return {CanAdapterHandle}
    */
   static canHandle(response) {
-    if(response.timings) {
-      return 'maybe'
+    if (response.timings) {
+      return 'maybe';
     }
 
     return 'no';
diff --git a/test/helpers/supported-clients/got-adapter.mjs b/test/helpers/supported-clients/got-adapter.mjs
index 11fb30b..095bba3 100644
--- a/test/helpers/supported-clients/got-adapter.mjs
+++ b/test/helpers/supported-clients/got-adapter.mjs
@@ -1,4 +1,4 @@
-import got from "got";
+import got from 'got';
 
 const gotTestAdapterClient = {
   name: 'axios',
@@ -59,4 +59,4 @@ const gotTestAdapterClient = {
   },
 };
 
-export {gotTestAdapterClient}
+export { gotTestAdapterClient };
diff --git a/test/helpers/supported-clients/index.js b/test/helpers/supported-clients/index.js
index 87b4dc0..1cf3ab5 100644
--- a/test/helpers/supported-clients/index.js
+++ b/test/helpers/supported-clients/index.js
@@ -1,5 +1,5 @@
 const { axiosTestAdapterClient } = require('./axios-adapter');
-const {gotTestAdapterClient} = require("./got-adapter.mjs");
+const { gotTestAdapterClient } = require('./got-adapter.mjs');
 
 /**
  * @type {TestAdapterClient[]}

From 05e2661409313e83d70d9b9f3f18f40bf28dc9a6 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:19:45 +0300
Subject: [PATCH 05/14] fix: make axios not always be the used client

---
 src/http-clients/axios-adapter.js | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/http-clients/axios-adapter.js b/src/http-clients/axios-adapter.js
index 9aa9134..0b96cab 100644
--- a/src/http-clients/axios-adapter.js
+++ b/src/http-clients/axios-adapter.js
@@ -14,12 +14,15 @@ class AxiosHttpClientAdapter extends HttpClientAdapter {
 
   /**
    *
-   * @param _response
+   * @param response
    * @return {CanAdapterHandle}
    */
-  static canHandle(_response) {
-    // TODO - implement
-    return 'maybe';
+  static canHandle(response) {
+    if (response.config) {
+      return 'maybe';
+    }
+
+    return 'no';
   }
 
   getUrl() {

From 938a7637f57af54b5197e7155a23486564610e47 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:39:30 +0300
Subject: [PATCH 06/14] test: add got adapter

---
 src/http-clients/axios-adapter.js             |  3 +
 src/http-clients/got-adapter.js               |  2 +-
 test/helpers/supported-clients/got-adapter.js | 77 +++++++++++++++++++
 .../helpers/supported-clients/got-adapter.mjs | 62 ---------------
 test/helpers/supported-clients/index.js       |  2 +-
 test/setup.js                                 | 60 +++++++++------
 6 files changed, 118 insertions(+), 88 deletions(-)
 create mode 100644 test/helpers/supported-clients/got-adapter.js
 delete mode 100644 test/helpers/supported-clients/got-adapter.mjs

diff --git a/src/http-clients/axios-adapter.js b/src/http-clients/axios-adapter.js
index 0b96cab..ecbbad2 100644
--- a/src/http-clients/axios-adapter.js
+++ b/src/http-clients/axios-adapter.js
@@ -5,6 +5,9 @@ const { HttpClientAdapter } = require('./adapter');
  */
 
 class AxiosHttpClientAdapter extends HttpClientAdapter {
+
+  static name = 'axios';
+
   /**
    * @param {AxiosResponse} response
    */
diff --git a/src/http-clients/got-adapter.js b/src/http-clients/got-adapter.js
index 1b0da44..12a24f8 100644
--- a/src/http-clients/got-adapter.js
+++ b/src/http-clients/got-adapter.js
@@ -8,7 +8,7 @@ const { HttpClientAdapter } = require('./adapter');
  * @extends {HttpClientAdapter<GotResponse>}
  */
 class GotHttpClientAdapter extends HttpClientAdapter {
-  name = 'got';
+  static name = 'got';
 
   /**
    * @param {GotResponse} response
diff --git a/test/helpers/supported-clients/got-adapter.js b/test/helpers/supported-clients/got-adapter.js
new file mode 100644
index 0000000..cd2e3b5
--- /dev/null
+++ b/test/helpers/supported-clients/got-adapter.js
@@ -0,0 +1,77 @@
+
+async function getGot() {
+  return (await import('got')).default
+}
+
+const gotTestAdapterClient = {
+  name: 'got',
+  async request(url, config) {
+    return (await getGot()).request({
+      url,
+      json: typeof config?.data === 'object' ? config?.data : undefined,
+      body: typeof config?.data !== 'object' ? config?.data : undefined,
+      method: config.method.toUpperCase(),
+      headers: config.headers,
+      searchParams: config.params,
+    });
+  },
+  async get(url, config) {
+    return (await getGot()).get(url, {
+      json: typeof config?.data === 'object' ? config?.data : undefined,
+      body: typeof config?.data !== 'object' ? config?.data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  async delete(url, config) {
+    return (await getGot()).delete(url, {
+      json: typeof config?.data === 'object' ? config?.data : undefined,
+      body: typeof config?.data !== 'object' ? config?.data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  async head(url, config) {
+    return (await getGot()).head(url, {
+      json: typeof config?.data === 'object' ? config?.data : undefined,
+      body: typeof config?.data !== 'object' ? config?.data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  async options(url, config) {
+    return (await getGot()).options(url, {
+      json: typeof config?.data === 'object' ? config?.data : undefined,
+      body: typeof config?.data !== 'object' ? config?.data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  async post(url, data, config) {
+    const response = await (await getGot()).post(url, {
+      json: typeof data === 'object' ? data : undefined,
+      body: typeof data !== 'object' ? data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+    return response;
+  },
+  async put(url, data, config) {
+    return (await getGot()).put(url, {
+      json: typeof data === 'object' ? data : undefined,
+      body: typeof data !== 'object' ? data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+  async patch(url, data, config) {
+    return (await getGot()).patch(url, {
+      json: typeof data === 'object' ? data : undefined,
+      body: typeof data !== 'object' ? data : undefined,
+      headers: config?.headers,
+      searchParams: config?.params,
+    });
+  },
+};
+
+module.exports = { gotTestAdapterClient };
diff --git a/test/helpers/supported-clients/got-adapter.mjs b/test/helpers/supported-clients/got-adapter.mjs
deleted file mode 100644
index 095bba3..0000000
--- a/test/helpers/supported-clients/got-adapter.mjs
+++ /dev/null
@@ -1,62 +0,0 @@
-import got from 'got';
-
-const gotTestAdapterClient = {
-  name: 'axios',
-  request(url, config) {
-    return got.request({
-      url,
-      body: config.data,
-      method: config.method.toUpperCase(),
-      headers: config.headers,
-      searchParams: config.params,
-    });
-  },
-  get(url, config) {
-    return got.get(url, {
-      body: config?.data,
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  delete(url, config) {
-    return got.delete(url, {
-      body: config?.data,
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  head(url, config) {
-    return got.head(url, {
-      body: config?.data,
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  options(url, config) {
-    return got.options(url, {
-      body: config?.data,
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  post(url, data, config) {
-    return got.post(url, data, {
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  put(url, data, config) {
-    return got.put(url, data, {
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-  patch(url, data, config) {
-    return got.patch(url, data, {
-      headers: config?.headers,
-      searchParams: config?.params,
-    });
-  },
-};
-
-export { gotTestAdapterClient };
diff --git a/test/helpers/supported-clients/index.js b/test/helpers/supported-clients/index.js
index 1cf3ab5..5fe35fb 100644
--- a/test/helpers/supported-clients/index.js
+++ b/test/helpers/supported-clients/index.js
@@ -1,5 +1,5 @@
 const { axiosTestAdapterClient } = require('./axios-adapter');
-const { gotTestAdapterClient } = require('./got-adapter.mjs');
+const { gotTestAdapterClient } = require('./got-adapter.js');
 
 /**
  * @type {TestAdapterClient[]}
diff --git a/test/setup.js b/test/setup.js
index e4e0d79..a7fd505 100644
--- a/test/setup.js
+++ b/test/setup.js
@@ -1,40 +1,52 @@
-const { snapshot, after } = require('node:test');
+
+const {snapshot, before, after} = require('node:test');
 const ansiSerializer = require('./helpers/ansi-snapshot-serializer/serializer');
 const axios = require('axios');
-const { closeServer } = require('./helpers/server-helper');
+const {closeServer} = require('./helpers/server-helper');
 
 // Don't throw on error
 axios.defaults.validateStatus = () => true;
 
+
 // Add a response interceptor
 axios.interceptors.response.use(function (response) {
-  // Delete the following headers as they are dynamic and the test snapshot won't match
-  delete response.headers['keep-alive'];
-  delete response.headers['date'];
+    // Delete the following headers as they are dynamic and the test snapshot won't match
+    delete response.headers['keep-alive'];
+    delete response.headers['date'];
 
-  return response;
+    return response;
 });
 
 snapshot.setDefaultSnapshotSerializers([
-  function getErrorMessage(input) {
-    return input instanceof Error ? input.message : input;
-  },
-  function ansiSnapshotSerializer(input) {
-    if (!ansiSerializer.test(input)) {
-      return input;
-    }
-
-    return ansiSerializer.serialize(input);
-  },
-
-  function defaultSnapshotSerializers(input) {
-    if (typeof input === 'string') {
-      return input;
-    }
-    return JSON.stringify(input, null, 2);
-  },
+    function getErrorMessage(input) {
+        return input instanceof Error ? input.message : input;
+    },
+    function ansiSnapshotSerializer(input) {
+        if (!ansiSerializer.test(input)) {
+            return input;
+        }
+
+        return ansiSerializer.serialize(input);
+    },
+
+    function defaultSnapshotSerializers(input) {
+        if (typeof input === 'string') {
+            return input;
+        }
+        return JSON.stringify(input, null, 2);
+    },
 ]);
 
+before(async () => {
+    const {default: got} = await import('got')
+
+    // Avoid throwing on error
+    got.extend({
+        // Don't throw on error
+        throwHttpErrors: false,
+    });
+})
+
 after(async () => {
-  await closeServer();
+    await closeServer();
 });

From c4320c7d9955deb08a850f595f2c5cf832d60589 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:13:04 +0300
Subject: [PATCH 07/14] feat(got): use the body in the response and fix test
 client

---
 src/http-clients/axios-adapter.js             |  1 -
 src/http-clients/got-adapter.js               |  2 +-
 test/helpers/can-test-snapshot.js             | 28 ++++++++
 test/helpers/override-http-client-defaults.js | 65 +++++++++++++++++++
 test/helpers/supported-clients/got-adapter.js |  5 +-
 test/setup.js                                 | 25 ++-----
 6 files changed, 99 insertions(+), 27 deletions(-)
 create mode 100644 test/helpers/can-test-snapshot.js
 create mode 100644 test/helpers/override-http-client-defaults.js

diff --git a/src/http-clients/axios-adapter.js b/src/http-clients/axios-adapter.js
index ecbbad2..e959d8e 100644
--- a/src/http-clients/axios-adapter.js
+++ b/src/http-clients/axios-adapter.js
@@ -5,7 +5,6 @@ const { HttpClientAdapter } = require('./adapter');
  */
 
 class AxiosHttpClientAdapter extends HttpClientAdapter {
-
   static name = 'axios';
 
   /**
diff --git a/src/http-clients/got-adapter.js b/src/http-clients/got-adapter.js
index 12a24f8..ff9b080 100644
--- a/src/http-clients/got-adapter.js
+++ b/src/http-clients/got-adapter.js
@@ -43,7 +43,7 @@ class GotHttpClientAdapter extends HttpClientAdapter {
   }
 
   getBody() {
-    return this.response.rawBody;
+    return this.response.body
   }
 }
 module.exports = { GotHttpClientAdapter };
diff --git a/test/helpers/can-test-snapshot.js b/test/helpers/can-test-snapshot.js
new file mode 100644
index 0000000..f725165
--- /dev/null
+++ b/test/helpers/can-test-snapshot.js
@@ -0,0 +1,28 @@
+const {printDiffOrStringify} = require("jest-matcher-utils");
+
+
+// Due to Jest bug with accessing getters that throw errors
+// and failing the matcher we can't test this
+// https://github.com/jestjs/jest/issues/15280
+function canTestSnapshot() {
+    try {
+        printDiffOrStringify({}, {
+            get a() {
+                throw new Error('simulate error');
+            }
+        }, 'expected', 'received', false);
+
+
+        // If it does not throw an error that we can create snapshot when there is a getter that throws an error
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+module.exports = {
+    canTestSnapshot,
+
+    shouldTestAsymmetricMatcherErrorsSnapshot(testClient) {
+        return testClient.name === 'got' && canTestSnapshot();
+    }
+}
diff --git a/test/helpers/override-http-client-defaults.js b/test/helpers/override-http-client-defaults.js
new file mode 100644
index 0000000..f1ae27f
--- /dev/null
+++ b/test/helpers/override-http-client-defaults.js
@@ -0,0 +1,65 @@
+const axios = require('axios');
+
+
+/**
+ * @type {import('got').Got | undefined}
+ */
+let got;
+
+async function getGot() {
+    if (!got) {
+        const defaultGot = (await import('got')).default;
+
+        // Avoid throwing on error
+        got = defaultGot.extend({
+            // Don't throw on error
+            throwHttpErrors: false,
+
+            // Don't retry
+            retry: {
+                limit: 0,
+            },
+
+            hooks: {
+                afterResponse: [
+                    (response) => {
+                        // Delete the following headers as they are dynamic and the test snapshot won't match
+                        delete response.headers['keep-alive'];
+                        delete response.headers['date'];
+
+                        return response;
+                    }
+                ],
+            },
+
+            mutableDefaults: true,
+        });
+    }
+
+    return got;
+}
+
+function fixHttpClients() {
+
+    // Don't throw on error
+    axios.defaults.validateStatus = () => true;
+
+    // Add a response interceptor
+    axios.interceptors.response.use(function (response) {
+        // Delete the following headers as they are dynamic and the test snapshot won't match
+        delete response.headers['keep-alive'];
+        delete response.headers['date'];
+
+        return response;
+    });
+
+    getGot().catch((e) => {
+        console.error('failed to get got', e);
+    });
+}
+
+
+module.exports = {
+    getGot,
+    fixHttpClients
+}
diff --git a/test/helpers/supported-clients/got-adapter.js b/test/helpers/supported-clients/got-adapter.js
index cd2e3b5..96b9bd0 100644
--- a/test/helpers/supported-clients/got-adapter.js
+++ b/test/helpers/supported-clients/got-adapter.js
@@ -1,7 +1,4 @@
-
-async function getGot() {
-  return (await import('got')).default
-}
+const {getGot} = require("../override-http-client-defaults");
 
 const gotTestAdapterClient = {
   name: 'got',
diff --git a/test/setup.js b/test/setup.js
index a7fd505..d4f5292 100644
--- a/test/setup.js
+++ b/test/setup.js
@@ -1,21 +1,10 @@
+const {fixHttpClients, getGot} = require("./helpers/override-http-client-defaults");
 
 const {snapshot, before, after} = require('node:test');
 const ansiSerializer = require('./helpers/ansi-snapshot-serializer/serializer');
-const axios = require('axios');
 const {closeServer} = require('./helpers/server-helper');
 
-// Don't throw on error
-axios.defaults.validateStatus = () => true;
-
-
-// Add a response interceptor
-axios.interceptors.response.use(function (response) {
-    // Delete the following headers as they are dynamic and the test snapshot won't match
-    delete response.headers['keep-alive'];
-    delete response.headers['date'];
-
-    return response;
-});
+fixHttpClients();
 
 snapshot.setDefaultSnapshotSerializers([
     function getErrorMessage(input) {
@@ -38,14 +27,8 @@ snapshot.setDefaultSnapshotSerializers([
 ]);
 
 before(async () => {
-    const {default: got} = await import('got')
-
-    // Avoid throwing on error
-    got.extend({
-        // Don't throw on error
-        throwHttpErrors: false,
-    });
-})
+    await getGot();
+});
 
 after(async () => {
     await closeServer();

From 40155c58b8430ebe7e88018adaae2ca50a0853e4 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:13:10 +0300
Subject: [PATCH 08/14] feat(got): use the body in the response and fix test
 client

---
 src/http-clients/got-adapter.js               |  2 +-
 test/helpers/can-test-snapshot.js             | 42 +++++----
 test/helpers/override-http-client-defaults.js | 91 +++++++++----------
 test/helpers/supported-clients/got-adapter.js |  2 +-
 test/setup.js                                 | 40 ++++----
 5 files changed, 89 insertions(+), 88 deletions(-)

diff --git a/src/http-clients/got-adapter.js b/src/http-clients/got-adapter.js
index ff9b080..7a472ce 100644
--- a/src/http-clients/got-adapter.js
+++ b/src/http-clients/got-adapter.js
@@ -43,7 +43,7 @@ class GotHttpClientAdapter extends HttpClientAdapter {
   }
 
   getBody() {
-    return this.response.body
+    return this.response.body;
   }
 }
 module.exports = { GotHttpClientAdapter };
diff --git a/test/helpers/can-test-snapshot.js b/test/helpers/can-test-snapshot.js
index f725165..4e7640c 100644
--- a/test/helpers/can-test-snapshot.js
+++ b/test/helpers/can-test-snapshot.js
@@ -1,28 +1,32 @@
-const {printDiffOrStringify} = require("jest-matcher-utils");
-
+const { printDiffOrStringify } = require('jest-matcher-utils');
 
 // Due to Jest bug with accessing getters that throw errors
 // and failing the matcher we can't test this
 // https://github.com/jestjs/jest/issues/15280
 function canTestSnapshot() {
-    try {
-        printDiffOrStringify({}, {
-            get a() {
-                throw new Error('simulate error');
-            }
-        }, 'expected', 'received', false);
-
+  try {
+    printDiffOrStringify(
+      {},
+      {
+        get a() {
+          throw new Error('simulate error');
+        },
+      },
+      'expected',
+      'received',
+      false,
+    );
 
-        // If it does not throw an error that we can create snapshot when there is a getter that throws an error
-        return true;
-    } catch (e) {
-        return false;
-    }
+    // If it does not throw an error that we can create snapshot when there is a getter that throws an error
+    return true;
+  } catch (e) {
+    return false;
+  }
 }
 module.exports = {
-    canTestSnapshot,
+  canTestSnapshot,
 
-    shouldTestAsymmetricMatcherErrorsSnapshot(testClient) {
-        return testClient.name === 'got' && canTestSnapshot();
-    }
-}
+  shouldTestAsymmetricMatcherErrorsSnapshot(testClient) {
+    return testClient.name === 'got' && canTestSnapshot();
+  },
+};
diff --git a/test/helpers/override-http-client-defaults.js b/test/helpers/override-http-client-defaults.js
index f1ae27f..692dc8b 100644
--- a/test/helpers/override-http-client-defaults.js
+++ b/test/helpers/override-http-client-defaults.js
@@ -1,65 +1,62 @@
 const axios = require('axios');
 
-
 /**
  * @type {import('got').Got | undefined}
  */
 let got;
 
 async function getGot() {
-    if (!got) {
-        const defaultGot = (await import('got')).default;
-
-        // Avoid throwing on error
-        got = defaultGot.extend({
-            // Don't throw on error
-            throwHttpErrors: false,
-
-            // Don't retry
-            retry: {
-                limit: 0,
-            },
-
-            hooks: {
-                afterResponse: [
-                    (response) => {
-                        // Delete the following headers as they are dynamic and the test snapshot won't match
-                        delete response.headers['keep-alive'];
-                        delete response.headers['date'];
-
-                        return response;
-                    }
-                ],
-            },
-
-            mutableDefaults: true,
-        });
-    }
+  if (!got) {
+    const defaultGot = (await import('got')).default;
+
+    // Avoid throwing on error
+    got = defaultGot.extend({
+      // Don't throw on error
+      throwHttpErrors: false,
+
+      // Don't retry
+      retry: {
+        limit: 0,
+      },
+
+      hooks: {
+        afterResponse: [
+          (response) => {
+            // Delete the following headers as they are dynamic and the test snapshot won't match
+            delete response.headers['keep-alive'];
+            delete response.headers['date'];
+
+            return response;
+          },
+        ],
+      },
+
+      mutableDefaults: true,
+    });
+  }
 
-    return got;
+  return got;
 }
 
 function fixHttpClients() {
+  // Don't throw on error
+  axios.defaults.validateStatus = () => true;
 
-    // Don't throw on error
-    axios.defaults.validateStatus = () => true;
-
-    // Add a response interceptor
-    axios.interceptors.response.use(function (response) {
-        // Delete the following headers as they are dynamic and the test snapshot won't match
-        delete response.headers['keep-alive'];
-        delete response.headers['date'];
+  // Add a response interceptor
+  axios.interceptors.response.use(function (response) {
+    // Delete the following headers as they are dynamic and the test snapshot won't match
+    delete response.headers['keep-alive'];
+    delete response.headers['date'];
 
-        return response;
-    });
+    return response;
+  });
 
-    getGot().catch((e) => {
-        console.error('failed to get got', e);
-    });
+  getGot().catch((e) => {
+    console.error('failed to get got', e);
+  });
 }
 
-
 module.exports = {
-    getGot,
-    fixHttpClients
-}
+  getGot,
+  fixHttpClients,
+};
diff --git a/test/helpers/supported-clients/got-adapter.js b/test/helpers/supported-clients/got-adapter.js
index 96b9bd0..b5e1e9a 100644
--- a/test/helpers/supported-clients/got-adapter.js
+++ b/test/helpers/supported-clients/got-adapter.js
@@ -1,4 +1,4 @@
-const {getGot} = require("../override-http-client-defaults");
+const { getGot } = require('../override-http-client-defaults');
 
 const gotTestAdapterClient = {
   name: 'got',
diff --git a/test/setup.js b/test/setup.js
index d4f5292..b1669b1 100644
--- a/test/setup.js
+++ b/test/setup.js
@@ -1,35 +1,35 @@
-const {fixHttpClients, getGot} = require("./helpers/override-http-client-defaults");
+const { fixHttpClients, getGot } = require('./helpers/override-http-client-defaults');
 
-const {snapshot, before, after} = require('node:test');
+const { snapshot, before, after } = require('node:test');
 const ansiSerializer = require('./helpers/ansi-snapshot-serializer/serializer');
-const {closeServer} = require('./helpers/server-helper');
+const { closeServer } = require('./helpers/server-helper');
 
 fixHttpClients();
 
 snapshot.setDefaultSnapshotSerializers([
-    function getErrorMessage(input) {
-        return input instanceof Error ? input.message : input;
-    },
-    function ansiSnapshotSerializer(input) {
-        if (!ansiSerializer.test(input)) {
-            return input;
-        }
+  function getErrorMessage(input) {
+    return input instanceof Error ? input.message : input;
+  },
+  function ansiSnapshotSerializer(input) {
+    if (!ansiSerializer.test(input)) {
+      return input;
+    }
 
-        return ansiSerializer.serialize(input);
-    },
+    return ansiSerializer.serialize(input);
+  },
 
-    function defaultSnapshotSerializers(input) {
-        if (typeof input === 'string') {
-            return input;
-        }
-        return JSON.stringify(input, null, 2);
-    },
+  function defaultSnapshotSerializers(input) {
+    if (typeof input === 'string') {
+      return input;
+    }
+    return JSON.stringify(input, null, 2);
+  },
 ]);
 
 before(async () => {
-    await getGot();
+  await getGot();
 });
 
 after(async () => {
-    await closeServer();
+  await closeServer();
 });

From 5cacccc19662a7aa933d3a2c210b6db24307b37c Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:13:32 +0300
Subject: [PATCH 09/14] test: add to have header

---
 test/matchers/headers/toHaveHeader.test.js    |  43 +-
 .../headers/toHaveHeader.test.js.snapshot     | 458 ++++++++++++++++++
 2 files changed, 480 insertions(+), 21 deletions(-)

diff --git a/test/matchers/headers/toHaveHeader.test.js b/test/matchers/headers/toHaveHeader.test.js
index bdde36a..7ff58ba 100644
--- a/test/matchers/headers/toHaveHeader.test.js
+++ b/test/matchers/headers/toHaveHeader.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../helpers/server-helper');
 const { testClients } = require('../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveHeader });
 
@@ -166,7 +167,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('Authorization'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is missing and there is another header that contain the expected header', async (t) => {
@@ -187,7 +188,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('X-Custom'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is missing and there is another header that is substring of the expected header', async (t) => {
@@ -208,7 +209,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('X-Custom-Header'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is missing when expected header value is provided', async (t) => {
@@ -230,7 +231,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('Authorization', 'hello'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header exist but the expected value does not match', async (t) => {
@@ -252,7 +253,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('x-custom-header', 'hello'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header exist but the expected value does not match but the value match another header value', async (t) => {
@@ -274,7 +275,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('x-custom-header', 'application/json'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header exist and passing asymmetric matcher as the expected value that does not match', async (t) => {
@@ -296,7 +297,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHeader('x-custom-header', expect.any(Number)),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -437,7 +438,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('Accept');
@@ -449,7 +450,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('Accept'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is present and the value is provided and match', async (t) => {
@@ -471,7 +472,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header', 'some value'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('Accept', 'application/json');
@@ -483,7 +484,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('Accept', 'application/json'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is present and the expected value is matching asymmetric matcher', async (t) => {
@@ -505,7 +506,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header', expect.any(String)),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('x-custom-header', expect.stringContaining('some'));
@@ -517,7 +518,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header', expect.stringContaining('some')),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('accept', expect.any(String));
@@ -529,7 +530,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('accept', expect.any(String)),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('accept', expect.stringContaining('application'));
@@ -541,7 +542,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('accept', expect.stringContaining('application')),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is present even when the header case is not the same (case insensitive)', async (t) => {
@@ -562,7 +563,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-CuStOm-heAdEr'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('X-CUSTOM-HEADER');
@@ -574,7 +575,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('X-CUSTOM-HEADER'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('x-custom-header');
@@ -586,7 +587,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected header is present even when the header case is not the same (case insensitive) and expected value is provided', async (t) => {
@@ -606,7 +607,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-CuStOm-heAdEr', 'some value'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('X-CUSTOM-HEADER', 'some value');
@@ -618,7 +619,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('X-CUSTOM-HEADER', 'some value'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
 
           try {
             expect(response).not.toHaveHeader('x-custom-header', 'some value');
@@ -630,7 +631,7 @@ describe('(.not).toHaveHeader', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHeader('x-custom-header', 'some value'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/headers/toHaveHeader.test.js.snapshot b/test/matchers/headers/toHaveHeader.test.js.snapshot
index 29db0b4..7e58832 100644
--- a/test/matchers/headers/toHaveHeader.test.js.snapshot
+++ b/test/matchers/headers/toHaveHeader.test.js.snapshot
@@ -455,3 +455,461 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and not providing expected header value 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>x-custom-header</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and not providing expected header value 2`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>Accept</color><dim>)</intensity>
+
+Expected header <green>"Accept"</color> to not exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the expected value is matching asymmetric matcher 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"x-custom-header", Any<String></color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not have value <green>Any<String></color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the expected value is matching asymmetric matcher 2`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"x-custom-header", StringContaining "some"</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not have value <green>StringContaining "some"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the expected value is matching asymmetric matcher 3`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"accept", Any<String></color><dim>)</intensity>
+
+Expected header <green>"accept"</color> to not have value <green>Any<String></color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the expected value is matching asymmetric matcher 4`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"accept", StringContaining "application"</color><dim>)</intensity>
+
+Expected header <green>"accept"</color> to not have value <green>StringContaining "application"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the value is provided and match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"x-custom-header", "some value"</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not have value <green>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present and the value is provided and match 2`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"Accept", "application/json"</color><dim>)</intensity>
+
+Expected header <green>"Accept"</color> to not have value <green>"application/json"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>x-CuStOm-heAdEr</color><dim>)</intensity>
+
+Expected header <green>"x-CuStOm-heAdEr"</color> to not exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) 2`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>X-CUSTOM-HEADER</color><dim>)</intensity>
+
+Expected header <green>"X-CUSTOM-HEADER"</color> to not exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) 3`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>x-custom-header</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) and expected value is provided 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"x-CuStOm-heAdEr", "some value"</color><dim>)</intensity>
+
+Expected header <green>"x-CuStOm-heAdEr"</color> to not have value <green>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) and expected value is provided 2`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"X-CUSTOM-HEADER", "some value"</color><dim>)</intensity>
+
+Expected header <green>"X-CUSTOM-HEADER"</color> to not have value <green>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .not.toHaveHeader > should fail when the expected header is present even when the header case is not the same (case insensitive) and expected value is provided 3`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHeader(</intensity><green>"x-custom-header", "some value"</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to not have value <green>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header exist and passing asymmetric matcher as the expected value that does not match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>"x-custom-header", Any<Number></color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to have value <green>Any<Number></color>
+But instead received: <red>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header exist but the expected value does not match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>"x-custom-header", "hello"</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to have value <green>"hello"</color>
+But instead received: <red>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header exist but the expected value does not match but the value match another header value 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>"x-custom-header", "application/json"</color><dim>)</intensity>
+
+Expected header <green>"x-custom-header"</color> to have value <green>"application/json"</color>
+But instead received: <red>"some value"</color>
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header is missing 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>Authorization</color><dim>)</intensity>
+
+Expected header <green>"Authorization"</color> to exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header is missing and there is another header that contain the expected header 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>X-Custom</color><dim>)</intensity>
+
+Expected header <green>"X-Custom"</color> to exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header is missing and there is another header that is substring of the expected header 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>X-Custom-Header</color><dim>)</intensity>
+
+Expected header <green>"X-Custom-Header"</color> to exists
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom": "some value",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHeader > using got > .toHaveHeader > should fail when the expected header is missing when expected header value is provided 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHeader(</intensity><green>"Authorization", "hello"</color><dim>)</intensity>
+
+Expected header <green>"Authorization"</color> to have value <green>"hello"</color>
+But no header with that name found
+
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/headers",
+  "status": 200,
+  "headers": {
+    "x-custom-header": "some value",
+    "accept": "application/json",
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;

From 94fb68542eb318aae505e9402210fb84d1c4f2a4 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:20:00 +0300
Subject: [PATCH 10/14] test: ignore jest error matching in got due to bug in
 jest

---
 test/matchers/data/toHaveBodyEquals.test.js   | 15 +--
 .../data/toHaveBodyMatchObject.test.js        | 97 ++++++++++---------
 .../status/generic/toBeSuccessful.test.js     |  5 +-
 .../status/generic/toHave2xxStatus.test.js    |  5 +-
 .../status/generic/toHave3xxStatus.test.js    |  5 +-
 .../status/generic/toHave4xxStatus.test.js    |  5 +-
 .../status/generic/toHave5xxStatus.test.js    |  5 +-
 .../status/generic/toHaveStatus.test.js       |  9 +-
 .../specific/toHaveAcceptedStatus.test.js     |  5 +-
 .../specific/toHaveBadGatewayStatus.test.js   |  5 +-
 .../specific/toHaveBadRequestStatus.test.js   |  5 +-
 .../specific/toHaveConflictStatus.test.js     |  5 +-
 .../specific/toHaveCreatedStatus.test.js      |  5 +-
 .../toHaveExpectationFailedStatus.test.js     |  5 +-
 .../toHaveFailedDependencyStatus.test.js      |  5 +-
 .../specific/toHaveForbiddenStatus.test.js    |  5 +-
 .../toHaveGatewayTimeoutStatus.test.js        |  5 +-
 .../status/specific/toHaveGoneStatus.test.js  |  5 +-
 ...oHaveHttpVersionNotSupportedStatus.test.js |  5 +-
 .../specific/toHaveImATeapotStatus.test.js    |  5 +-
 ...eInsufficientSpaceOnResourceStatus.test.js |  5 +-
 .../toHaveInsufficientStorageStatus.test.js   |  5 +-
 .../toHaveInternalServerErrorStatus.test.js   |  5 +-
 .../toHaveLengthRequiredStatus.test.js        |  5 +-
 .../specific/toHaveLockedStatus.test.js       |  5 +-
 .../toHaveMethodFailureStatus.test.js         |  5 +-
 .../toHaveMethodNotAllowedStatus.test.js      |  5 +-
 .../toHaveMisdirectedRequestStatus.test.js    |  5 +-
 .../toHaveMovedPermanentlyStatus.test.js      |  5 +-
 .../toHaveMovedTemporarilyStatus.test.js      |  5 +-
 .../specific/toHaveMultiStatusStatus.test.js  |  5 +-
 .../toHaveMultipleChoicesStatus.test.js       |  5 +-
 ...etworkAuthenticationRequiredStatus.test.js |  5 +-
 .../specific/toHaveNoContentStatus.test.js    |  5 +-
 ...eNonAuthoritativeInformationStatus.test.js |  5 +-
 .../toHaveNotAcceptableStatus.test.js         |  5 +-
 .../specific/toHaveNotFoundStatus.test.js     |  5 +-
 .../toHaveNotImplementedStatus.test.js        |  5 +-
 .../specific/toHaveNotModifiedStatus.test.js  |  5 +-
 .../status/specific/toHaveOkStatus.test.js    |  5 +-
 .../toHavePartialContentStatus.test.js        |  5 +-
 .../toHavePaymentRequiredStatus.test.js       |  5 +-
 .../toHavePermanentRedirectStatus.test.js     |  5 +-
 .../toHavePreconditionFailedStatus.test.js    |  5 +-
 .../toHavePreconditionRequiredStatus.test.js  |  5 +-
 ...eProxyAuthenticationRequiredStatus.test.js |  5 +-
 ...eRequestHeaderFieldsTooLargeStatus.test.js |  5 +-
 .../toHaveRequestTimeoutStatus.test.js        |  5 +-
 .../toHaveRequestTooLongStatus.test.js        |  5 +-
 .../toHaveRequestUriTooLongStatus.test.js     |  5 +-
 ...RequestedRangeNotSatisfiableStatus.test.js |  5 +-
 .../specific/toHaveResetContentStatus.test.js |  5 +-
 .../specific/toHaveSeeOtherStatus.test.js     |  5 +-
 .../toHaveServiceUnavailableStatus.test.js    |  5 +-
 .../toHaveSwitchingProtocolsStatus.test.js    |  5 +-
 .../toHaveTemporaryRedirectStatus.test.js     |  5 +-
 .../toHaveTooManyRequestsStatus.test.js       |  5 +-
 .../specific/toHaveUnauthorizedStatus.test.js |  5 +-
 ...veUnavailableForLegalReasonsStatus.test.js |  5 +-
 .../toHaveUnprocessableEntityStatus.test.js   |  5 +-
 .../toHaveUnsupportedMediaTypeStatus.test.js  |  5 +-
 .../toHaveUpgradeRequiredStatus.test.js       |  5 +-
 .../specific/toHaveUseProxyStatus.test.js     |  5 +-
 63 files changed, 242 insertions(+), 179 deletions(-)

diff --git a/test/matchers/data/toHaveBodyEquals.test.js b/test/matchers/data/toHaveBodyEquals.test.js
index 1bcfa64..f4105e5 100644
--- a/test/matchers/data/toHaveBodyEquals.test.js
+++ b/test/matchers/data/toHaveBodyEquals.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../helpers/server-helper');
 const { testClients } = require('../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveBodyEquals });
 
@@ -136,7 +137,7 @@ describe('(.not).toHaveBodyEquals', () => {
                 g: {},
               }),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the text data does not match', async (t) => {
@@ -158,7 +159,7 @@ describe('(.not).toHaveBodyEquals', () => {
             expect({ response }).toEqual({
               response: expect.toHaveBodyEquals('Someone'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the json data does not match when using asymmetric matchers in the data', async (t) => {
@@ -196,7 +197,7 @@ describe('(.not).toHaveBodyEquals', () => {
                 }),
               ),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the response body type does not match', async (t) => {
@@ -220,7 +221,7 @@ describe('(.not).toHaveBodyEquals', () => {
             expect({ response }).toEqual({
               response: expect.toHaveBodyEquals('Hello World'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -355,7 +356,7 @@ describe('(.not).toHaveBodyEquals', () => {
                 g: {},
               }),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected data match and body is text', async (t) => {
@@ -377,7 +378,7 @@ describe('(.not).toHaveBodyEquals', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveBodyEquals('Hello World'),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the expected data match and body is json when using asymmetric matchers in the data', async (t) => {
@@ -417,7 +418,7 @@ describe('(.not).toHaveBodyEquals', () => {
                 }),
               ),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
diff --git a/test/matchers/data/toHaveBodyMatchObject.test.js b/test/matchers/data/toHaveBodyMatchObject.test.js
index ea636f2..53af8ef 100644
--- a/test/matchers/data/toHaveBodyMatchObject.test.js
+++ b/test/matchers/data/toHaveBodyMatchObject.test.js
@@ -4,6 +4,7 @@ const { describe, before, it } = require('node:test');
 const { buildServer } = require('../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../helpers/can-test-snapshot');
 const { testClients } = require('../../helpers/supported-clients');
 
 expect.extend({ toHaveBodyMatchObject });
@@ -41,7 +42,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
                 a: '1',
               }),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         it('should fail when the received response body have content type plain/text even though the data itself is JSON string ', async (t) => {
@@ -63,7 +64,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
             expect({ response }).toEqual({
               response: expect.toHaveBodyMatchObject({}),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -201,7 +202,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(circularObjA1),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it('should not pass when expected object contain transitive circular references as its not possible in response object', async (t) => {
@@ -231,7 +232,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(transitiveCircularObjA1),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
         });
 
@@ -261,7 +262,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject({ a: undefined }),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b'}`, async (t) => {
@@ -289,7 +290,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b', c: 'd'}`, async (t) => {
@@ -317,7 +318,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {a: 'b', t: {z: 'z'}}`, async (t) => {
@@ -345,7 +346,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {t: {x: {r: 'r'}}}`, async (t) => {
@@ -373,7 +374,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4, 5]}`, async (t) => {
@@ -401,7 +402,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: [3, 4, 5, 'v'], b: 'b'} and expected value is {a: [3, 4, 5, 'v']}`, async (t) => {
@@ -429,7 +430,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 1, c: 2} and expected value is {a: expect.any(Number)}`, async (t) => {
@@ -457,7 +458,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: {x: 'x', y: 'y'}} and expected value is {a: {x: expect.any(String)}}`, async (t) => {
@@ -485,7 +486,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: null, b: 'b'} and expected value is {a: null}`, async (t) => {
@@ -513,7 +514,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {b: 'b'} and expected value is {}`, async (t) => {
@@ -541,7 +542,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: [{a: 'a', b: 'b'}]} and expected value is {a: [{a: 'a'}]}`, async (t) => {
@@ -569,7 +570,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is [1, 2] and expected value is [1, 2]`, async (t) => {
@@ -597,7 +598,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {} and expected value is {}`, async (t) => {
@@ -625,7 +626,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is [] and expected value is []`, async (t) => {
@@ -653,7 +654,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {message: 'bar'} and expected value is {message: 'bar'}`, async (t) => {
@@ -681,7 +682,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is {a: 'b'} and expected value is Object.assign(Object.create(null), {a: 'b'})`, async (t) => {
@@ -711,7 +712,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
             //     expect({response}).toEqual({
             //         response: expect.not.toHaveBodyMatchObject(expectedValue),
             //     }),
-            // ).toThrowError(JestAssertionError);
+            // ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should pass when the response body is [0] and expected value is [-0] as -0 and 0 are the same value in JSON`, async (t) => {
@@ -739,7 +740,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.not.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
         });
 
@@ -770,7 +771,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b!', c: 'd'}`, async (t) => {
@@ -799,7 +800,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 'a', c: 'd'} and expected value is {a: expect.any(Number)}`, async (t) => {
@@ -828,7 +829,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {a: 'b', t: {z: [3]}}`, async (t) => {
@@ -857,7 +858,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {t: {l: {r: 'r'}}}`, async (t) => {
@@ -886,7 +887,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4, 5, 6]}`, async (t) => {
@@ -915,7 +916,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4]}`, async (t) => {
@@ -944,7 +945,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [3, 4, 'v'], b: 'b'} and expected value is {a: ['v']}`, async (t) => {
@@ -973,7 +974,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: {b: 4}}`, async (t) => {
@@ -1002,7 +1003,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: {b: expect.any(String)}}`, async (t) => {
@@ -1031,7 +1032,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is [1, 2] and expected value is [1, 3]`, async (t) => {
@@ -1060,7 +1061,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: {}} and expected value is {a: new Set([])}`, async (t) => {
@@ -1089,7 +1090,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: new Date('2015-11-30').toISOString(), b: 'b'} and expected value is {a: new Date('2015-10-10')}`, async (t) => {
@@ -1118,7 +1119,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: null, b: 'b'} and expected value is {a: '4'}`, async (t) => {
@@ -1147,7 +1148,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {} and expected value is  {a: null}`, async (t) => {
@@ -1176,7 +1177,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: [{a: 'a', b: 'b'}]} and expected value is {a: [{a: 'c'}]}`, async (t) => {
@@ -1205,7 +1206,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 1, b: 1, c: 1, d: {e: {f: 555}}} and expected value is {d: {e: {f: 222}}}`, async (t) => {
@@ -1234,7 +1235,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is [1, 2, 3] and expected value is [2, 3, 1]`, async (t) => {
@@ -1263,7 +1264,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is [1, 2, 3] and expected value is [1, 2, 2]`, async (t) => {
@@ -1292,7 +1293,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {c: 'd'} and expected value is Object.assign(Object.create(null), {a: 'b'})`, async (t) => {
@@ -1322,7 +1323,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
             //     expect({response}).toEqual({
             //         response: expect.toHaveBodyMatchObject(expectedValue),
             //     }),
-            // ).toThrowError(JestAssertionError);
+            // ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is { a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers' } and expected value is {a: 'c', [Symbol.for('expect-http-client-matchers')]: expect.any(String)}`, async (t) => {
@@ -1355,7 +1356,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is { a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers' } and expected value is {a: 'b', [Symbol.for('expect-http-client-matchers')]: 'expect-http-client-matchers'}`, async (t) => {
@@ -1391,7 +1392,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers'} and expected value is {a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers')]: 'expect-http-client-matchers'}`, async (t) => {
@@ -1428,7 +1429,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: undefined, b: 'b'} and expected value is new Foo() as cant match because classes are not valid JSON value`, async (t) => {
@@ -1457,7 +1458,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {a: undefined, b: 'b', c: 'c'} and expected value is new Sub()`, async (t) => {
@@ -1486,7 +1487,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
 
           it(`should not match when the response body is {d: 4} and expected value is withDefineProperty(new Sub(), 'd', 4)`, async (t) => {
@@ -1515,7 +1516,7 @@ describe('(.not).toHaveBodyMatchObject', () => {
               expect({ response }).toEqual({
                 response: expect.toHaveBodyMatchObject(expectedValue),
               }),
-            ).toThrowError(JestAssertionError);
+            ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
           });
         });
 
diff --git a/test/matchers/status/generic/toBeSuccessful.test.js b/test/matchers/status/generic/toBeSuccessful.test.js
index 36446fc..779180e 100644
--- a/test/matchers/status/generic/toBeSuccessful.test.js
+++ b/test/matchers/status/generic/toBeSuccessful.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toBeSuccessful });
@@ -60,7 +61,7 @@ describe('(.not).toBeSuccessful', () => {
                 expect({ response }).toEqual({
                   response: expect.toBeSuccessful(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -106,7 +107,7 @@ describe('(.not).toBeSuccessful', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toBeSuccessful(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/generic/toHave2xxStatus.test.js b/test/matchers/status/generic/toHave2xxStatus.test.js
index 89b32f1..c52f908 100644
--- a/test/matchers/status/generic/toHave2xxStatus.test.js
+++ b/test/matchers/status/generic/toHave2xxStatus.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toHave2xxStatus });
@@ -59,7 +60,7 @@ describe('(.not).toHave2xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.toHave2xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -104,7 +105,7 @@ describe('(.not).toHave2xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toHave2xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/generic/toHave3xxStatus.test.js b/test/matchers/status/generic/toHave3xxStatus.test.js
index 64fc4a5..098922e 100644
--- a/test/matchers/status/generic/toHave3xxStatus.test.js
+++ b/test/matchers/status/generic/toHave3xxStatus.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toHave3xxStatus });
@@ -59,7 +60,7 @@ describe('(.not).toHave3xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.toHave3xxStatus(),
                 }),
-              ).toThrowError(JestAssertionError);
+              ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -104,7 +105,7 @@ describe('(.not).toHave3xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toHave3xxStatus(),
                 }),
-              ).toThrowError(JestAssertionError);
+              ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/generic/toHave4xxStatus.test.js b/test/matchers/status/generic/toHave4xxStatus.test.js
index 1c9bc0a..bca1f9b 100644
--- a/test/matchers/status/generic/toHave4xxStatus.test.js
+++ b/test/matchers/status/generic/toHave4xxStatus.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toHave4xxStatus });
@@ -62,7 +63,7 @@ describe('(.not).toHave4xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.toHave4xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -110,7 +111,7 @@ describe('(.not).toHave4xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toHave4xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/generic/toHave5xxStatus.test.js b/test/matchers/status/generic/toHave5xxStatus.test.js
index 55c5938..56d3bf9 100644
--- a/test/matchers/status/generic/toHave5xxStatus.test.js
+++ b/test/matchers/status/generic/toHave5xxStatus.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toHave5xxStatus });
@@ -60,7 +61,7 @@ describe('(.not).toHave5xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.toHave5xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -106,7 +107,7 @@ describe('(.not).toHave5xxStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toHave5xxStatus(),
                 });
-              }).toThrowError(JestAssertionError);
+              }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/generic/toHaveStatus.test.js b/test/matchers/status/generic/toHaveStatus.test.js
index 29863de..625bbc1 100644
--- a/test/matchers/status/generic/toHaveStatus.test.js
+++ b/test/matchers/status/generic/toHaveStatus.test.js
@@ -4,6 +4,7 @@ const { describe, test, before } = require('node:test');
 const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 const { testClients } = require('../../../helpers/supported-clients');
 
 expect.extend({ toHaveStatus });
@@ -75,7 +76,7 @@ describe('(.not).toHaveStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveStatus(expect.any(String)),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         describe('status 200 to 599', function allTests() {
@@ -98,7 +99,7 @@ describe('(.not).toHaveStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.toHaveStatus(status - 1),
                 }),
-              ).toThrowError(JestAssertionError);
+              ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
@@ -159,7 +160,7 @@ describe('(.not).toHaveStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveStatus(expect.any(Number)),
             }),
-          ).toThrowError(JestAssertionError);
+          ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
 
         describe('status 200 to 599', function allTests() {
@@ -182,7 +183,7 @@ describe('(.not).toHaveStatus', () => {
                 expect({ response }).toEqual({
                   response: expect.not.toHaveStatus(status),
                 }),
-              ).toThrowError(JestAssertionError);
+              ).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
             });
           }
         });
diff --git a/test/matchers/status/specific/toHaveAcceptedStatus.test.js b/test/matchers/status/specific/toHaveAcceptedStatus.test.js
index 788ed46..527a1e7 100644
--- a/test/matchers/status/specific/toHaveAcceptedStatus.test.js
+++ b/test/matchers/status/specific/toHaveAcceptedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveAcceptedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveAcceptedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveAcceptedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveAcceptedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveAcceptedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveBadGatewayStatus.test.js b/test/matchers/status/specific/toHaveBadGatewayStatus.test.js
index 43b77ef..d56f9c6 100644
--- a/test/matchers/status/specific/toHaveBadGatewayStatus.test.js
+++ b/test/matchers/status/specific/toHaveBadGatewayStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveBadGatewayStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveBadGatewayStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveBadGatewayStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveBadGatewayStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveBadGatewayStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveBadRequestStatus.test.js b/test/matchers/status/specific/toHaveBadRequestStatus.test.js
index 6d7f62d..d5c0f90 100644
--- a/test/matchers/status/specific/toHaveBadRequestStatus.test.js
+++ b/test/matchers/status/specific/toHaveBadRequestStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveBadRequestStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveBadRequestStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveBadRequestStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveBadRequestStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveBadRequestStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveConflictStatus.test.js b/test/matchers/status/specific/toHaveConflictStatus.test.js
index bb37fe9..c1203b5 100644
--- a/test/matchers/status/specific/toHaveConflictStatus.test.js
+++ b/test/matchers/status/specific/toHaveConflictStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveConflictStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveConflictStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveConflictStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveConflictStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveConflictStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveCreatedStatus.test.js b/test/matchers/status/specific/toHaveCreatedStatus.test.js
index d13f738..cf566d5 100644
--- a/test/matchers/status/specific/toHaveCreatedStatus.test.js
+++ b/test/matchers/status/specific/toHaveCreatedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveCreatedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveCreatedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveCreatedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveCreatedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveCreatedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js b/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js
index e051d9c..24e7042 100644
--- a/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js
+++ b/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveExpectationFailedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveExpectationFailedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveExpectationFailedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveExpectationFailedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveExpectationFailedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js b/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js
index 0a6091f..dedba92 100644
--- a/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js
+++ b/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveFailedDependencyStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveFailedDependencyStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveFailedDependencyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveFailedDependencyStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveFailedDependencyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveForbiddenStatus.test.js b/test/matchers/status/specific/toHaveForbiddenStatus.test.js
index 4ef853c..90395f7 100644
--- a/test/matchers/status/specific/toHaveForbiddenStatus.test.js
+++ b/test/matchers/status/specific/toHaveForbiddenStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveForbiddenStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveForbiddenStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveForbiddenStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveForbiddenStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveForbiddenStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js b/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js
index 7fffbb2..f1efe7d 100644
--- a/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js
+++ b/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveGatewayTimeoutStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveGatewayTimeoutStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveGatewayTimeoutStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveGatewayTimeoutStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveGatewayTimeoutStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveGoneStatus.test.js b/test/matchers/status/specific/toHaveGoneStatus.test.js
index f6a03b1..be73785 100644
--- a/test/matchers/status/specific/toHaveGoneStatus.test.js
+++ b/test/matchers/status/specific/toHaveGoneStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveGoneStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveGoneStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveGoneStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveGoneStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveGoneStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js b/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js
index e6206d7..32064d2 100644
--- a/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js
+++ b/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveHttpVersionNotSupportedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveHttpVersionNotSupportedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveHttpVersionNotSupportedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveHttpVersionNotSupportedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveHttpVersionNotSupportedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveImATeapotStatus.test.js b/test/matchers/status/specific/toHaveImATeapotStatus.test.js
index 9a04181..950f4fd 100644
--- a/test/matchers/status/specific/toHaveImATeapotStatus.test.js
+++ b/test/matchers/status/specific/toHaveImATeapotStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveImATeapotStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveImATeapotStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveImATeapotStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveImATeapotStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveImATeapotStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js b/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js
index d790d25..451c1ef 100644
--- a/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js
+++ b/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveInsufficientSpaceOnResourceStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveInsufficientSpaceOnResourceStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveInsufficientSpaceOnResourceStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveInsufficientSpaceOnResourceStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveInsufficientSpaceOnResourceStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js b/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js
index 12b233d..b9cb168 100644
--- a/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js
+++ b/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveInsufficientStorageStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveInsufficientStorageStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveInsufficientStorageStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveInsufficientStorageStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveInsufficientStorageStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js b/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js
index bf42530..a14546a 100644
--- a/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js
+++ b/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveInternalServerErrorStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveInternalServerErrorStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveInternalServerErrorStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveInternalServerErrorStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveInternalServerErrorStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js b/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js
index 0e31b76..8537230 100644
--- a/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveLengthRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveLengthRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveLengthRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveLengthRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveLengthRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveLockedStatus.test.js b/test/matchers/status/specific/toHaveLockedStatus.test.js
index 27fd2b4..94f724a 100644
--- a/test/matchers/status/specific/toHaveLockedStatus.test.js
+++ b/test/matchers/status/specific/toHaveLockedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveLockedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveLockedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveLockedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveLockedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveLockedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMethodFailureStatus.test.js b/test/matchers/status/specific/toHaveMethodFailureStatus.test.js
index f8f6605..e40d160 100644
--- a/test/matchers/status/specific/toHaveMethodFailureStatus.test.js
+++ b/test/matchers/status/specific/toHaveMethodFailureStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMethodFailureStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMethodFailureStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMethodFailureStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMethodFailureStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMethodFailureStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js b/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js
index 219275d..82e65d7 100644
--- a/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js
+++ b/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMethodNotAllowedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMethodNotAllowedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMethodNotAllowedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMethodNotAllowedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMethodNotAllowedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js b/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js
index 41634e1..f3833ab 100644
--- a/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js
+++ b/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMisdirectedRequestStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMisdirectedRequestStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMisdirectedRequestStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMisdirectedRequestStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMisdirectedRequestStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js b/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js
index 4528c15..20483f2 100644
--- a/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js
+++ b/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMovedPermanentlyStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMovedPermanentlyStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMovedPermanentlyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMovedPermanentlyStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMovedPermanentlyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js b/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js
index 8c44eb0..093bffd 100644
--- a/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js
+++ b/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMovedTemporarilyStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMovedTemporarilyStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMovedTemporarilyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMovedTemporarilyStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMovedTemporarilyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMultiStatusStatus.test.js b/test/matchers/status/specific/toHaveMultiStatusStatus.test.js
index d501895..f1211e8 100644
--- a/test/matchers/status/specific/toHaveMultiStatusStatus.test.js
+++ b/test/matchers/status/specific/toHaveMultiStatusStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMultiStatusStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMultiStatusStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMultiStatusStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMultiStatusStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMultiStatusStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js b/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js
index e27e183..60ebc70 100644
--- a/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js
+++ b/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveMultipleChoicesStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveMultipleChoicesStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveMultipleChoicesStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveMultipleChoicesStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveMultipleChoicesStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js b/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js
index 9aefb7d..d0873f8 100644
--- a/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNetworkAuthenticationRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNetworkAuthenticationRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNetworkAuthenticationRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNetworkAuthenticationRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNetworkAuthenticationRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNoContentStatus.test.js b/test/matchers/status/specific/toHaveNoContentStatus.test.js
index f1b1144..1b29686 100644
--- a/test/matchers/status/specific/toHaveNoContentStatus.test.js
+++ b/test/matchers/status/specific/toHaveNoContentStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNoContentStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNoContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNoContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNoContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNoContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js b/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js
index e22f739..abad324 100644
--- a/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js
+++ b/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNonAuthoritativeInformationStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNonAuthoritativeInformationStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNonAuthoritativeInformationStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNonAuthoritativeInformationStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNonAuthoritativeInformationStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js b/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js
index 7a996c8..a95e8e9 100644
--- a/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js
+++ b/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNotAcceptableStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNotAcceptableStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNotAcceptableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNotAcceptableStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNotAcceptableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNotFoundStatus.test.js b/test/matchers/status/specific/toHaveNotFoundStatus.test.js
index ffb8d93..77941a7 100644
--- a/test/matchers/status/specific/toHaveNotFoundStatus.test.js
+++ b/test/matchers/status/specific/toHaveNotFoundStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNotFoundStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNotFoundStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNotFoundStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNotFoundStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNotFoundStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNotImplementedStatus.test.js b/test/matchers/status/specific/toHaveNotImplementedStatus.test.js
index aea542d..1d77cc5 100644
--- a/test/matchers/status/specific/toHaveNotImplementedStatus.test.js
+++ b/test/matchers/status/specific/toHaveNotImplementedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNotImplementedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNotImplementedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNotImplementedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNotImplementedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNotImplementedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveNotModifiedStatus.test.js b/test/matchers/status/specific/toHaveNotModifiedStatus.test.js
index 9f5bdb4..3117480 100644
--- a/test/matchers/status/specific/toHaveNotModifiedStatus.test.js
+++ b/test/matchers/status/specific/toHaveNotModifiedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveNotModifiedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveNotModifiedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveNotModifiedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveNotModifiedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveNotModifiedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveOkStatus.test.js b/test/matchers/status/specific/toHaveOkStatus.test.js
index fa952e4..1e30b7b 100644
--- a/test/matchers/status/specific/toHaveOkStatus.test.js
+++ b/test/matchers/status/specific/toHaveOkStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveOkStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveOkStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveOkStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveOkStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveOkStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHavePartialContentStatus.test.js b/test/matchers/status/specific/toHavePartialContentStatus.test.js
index 3f4d488..c263830 100644
--- a/test/matchers/status/specific/toHavePartialContentStatus.test.js
+++ b/test/matchers/status/specific/toHavePartialContentStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHavePartialContentStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHavePartialContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHavePartialContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHavePartialContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHavePartialContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js b/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js
index abb3803..2adf6f2 100644
--- a/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHavePaymentRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHavePaymentRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHavePaymentRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHavePaymentRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHavePaymentRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js b/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js
index 4b311d0..29fdf02 100644
--- a/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js
+++ b/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHavePermanentRedirectStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHavePermanentRedirectStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHavePermanentRedirectStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHavePermanentRedirectStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHavePermanentRedirectStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js b/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js
index 467a44f..c930853 100644
--- a/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js
+++ b/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHavePreconditionFailedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHavePreconditionFailedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHavePreconditionFailedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHavePreconditionFailedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHavePreconditionFailedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js b/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js
index 9c15ad3..64769e2 100644
--- a/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHavePreconditionRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHavePreconditionRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHavePreconditionRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHavePreconditionRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHavePreconditionRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js b/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js
index d5f8a7e..56cc29a 100644
--- a/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveProxyAuthenticationRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveProxyAuthenticationRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveProxyAuthenticationRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveProxyAuthenticationRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveProxyAuthenticationRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js b/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js
index da45842..f1e1e8d 100644
--- a/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js
+++ b/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveRequestHeaderFieldsTooLargeStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveRequestHeaderFieldsTooLargeStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveRequestHeaderFieldsTooLargeStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveRequestHeaderFieldsTooLargeStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveRequestHeaderFieldsTooLargeStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js b/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js
index 30f3917..2fe607d 100644
--- a/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js
+++ b/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveRequestTimeoutStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveRequestTimeoutStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveRequestTimeoutStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveRequestTimeoutStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveRequestTimeoutStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js b/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js
index 80aa6b1..b23cf20 100644
--- a/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js
+++ b/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveRequestTooLongStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveRequestTooLongStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveRequestTooLongStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveRequestTooLongStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveRequestTooLongStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js b/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js
index 8bfd527..56a520d 100644
--- a/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js
+++ b/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveRequestUriTooLongStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveRequestUriTooLongStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveRequestUriTooLongStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveRequestUriTooLongStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveRequestUriTooLongStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js b/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js
index c704b56..0be4890 100644
--- a/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js
+++ b/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveRequestedRangeNotSatisfiableStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveRequestedRangeNotSatisfiableStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveRequestedRangeNotSatisfiableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveRequestedRangeNotSatisfiableStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveRequestedRangeNotSatisfiableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveResetContentStatus.test.js b/test/matchers/status/specific/toHaveResetContentStatus.test.js
index 60501a5..14b4f3e 100644
--- a/test/matchers/status/specific/toHaveResetContentStatus.test.js
+++ b/test/matchers/status/specific/toHaveResetContentStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveResetContentStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveResetContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveResetContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveResetContentStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveResetContentStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveSeeOtherStatus.test.js b/test/matchers/status/specific/toHaveSeeOtherStatus.test.js
index 30ef7c1..d46ff61 100644
--- a/test/matchers/status/specific/toHaveSeeOtherStatus.test.js
+++ b/test/matchers/status/specific/toHaveSeeOtherStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveSeeOtherStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveSeeOtherStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveSeeOtherStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveSeeOtherStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveSeeOtherStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js b/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js
index a7b3835..0064482 100644
--- a/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js
+++ b/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveServiceUnavailableStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveServiceUnavailableStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveServiceUnavailableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveServiceUnavailableStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveServiceUnavailableStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js b/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js
index 51def41..5573f56 100644
--- a/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js
+++ b/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveSwitchingProtocolsStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveSwitchingProtocolsStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveSwitchingProtocolsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveSwitchingProtocolsStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveSwitchingProtocolsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js b/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js
index 25a896e..67ae9e1 100644
--- a/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js
+++ b/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveTemporaryRedirectStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveTemporaryRedirectStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveTemporaryRedirectStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveTemporaryRedirectStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveTemporaryRedirectStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js b/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js
index 88a43cd..4a3a981 100644
--- a/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js
+++ b/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveTooManyRequestsStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveTooManyRequestsStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveTooManyRequestsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveTooManyRequestsStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveTooManyRequestsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js b/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js
index 16c24a9..5fcbd1e 100644
--- a/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js
+++ b/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUnauthorizedStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUnauthorizedStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUnauthorizedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUnauthorizedStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUnauthorizedStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js b/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js
index 6a3965b..c7dd89f 100644
--- a/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js
+++ b/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUnavailableForLegalReasonsStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUnavailableForLegalReasonsStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUnavailableForLegalReasonsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUnavailableForLegalReasonsStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUnavailableForLegalReasonsStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js b/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js
index ecc8df5..052269b 100644
--- a/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js
+++ b/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUnprocessableEntityStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUnprocessableEntityStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUnprocessableEntityStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUnprocessableEntityStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUnprocessableEntityStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js b/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js
index e5ebca6..98c9787 100644
--- a/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js
+++ b/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUnsupportedMediaTypeStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUnsupportedMediaTypeStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUnsupportedMediaTypeStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUnsupportedMediaTypeStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUnsupportedMediaTypeStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js b/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js
index 8458e62..b5b60e3 100644
--- a/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js
+++ b/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUpgradeRequiredStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUpgradeRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUpgradeRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUpgradeRequiredStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUpgradeRequiredStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });
diff --git a/test/matchers/status/specific/toHaveUseProxyStatus.test.js b/test/matchers/status/specific/toHaveUseProxyStatus.test.js
index 7f39c82..edc535f 100644
--- a/test/matchers/status/specific/toHaveUseProxyStatus.test.js
+++ b/test/matchers/status/specific/toHaveUseProxyStatus.test.js
@@ -5,6 +5,7 @@ const { buildServer } = require('../../../helpers/server-helper.js');
 const { expect, JestAssertionError } = require('expect');
 const { getServerUrl } = require('../../../helpers/server-helper');
 const { testClients } = require('../../../helpers/supported-clients');
+const { shouldTestAsymmetricMatcherErrorsSnapshot } = require('../../../helpers/can-test-snapshot');
 
 expect.extend({ toHaveUseProxyStatus });
 
@@ -52,7 +53,7 @@ describe('(.not).toHaveUseProxyStatus', () => {
             expect({ response }).toEqual({
               response: expect.toHaveUseProxyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
 
@@ -93,7 +94,7 @@ describe('(.not).toHaveUseProxyStatus', () => {
             expect({ response }).toEqual({
               response: expect.not.toHaveUseProxyStatus(),
             });
-          }).toThrowError(JestAssertionError);
+          }).toThrowError(shouldTestAsymmetricMatcherErrorsSnapshot(testClient) ? JestAssertionError : Error);
         });
       });
     });

From 3746804a65dd0f93c8c7e9e06c342a88f28ec659 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:20:21 +0300
Subject: [PATCH 11/14] test: add snapshots

---
 .../data/toHaveBodyEquals.test.js.snapshot    |   166 +
 .../toHaveBodyMatchObject.test.js.snapshot    |  1142 ++
 .../generic/toBeSuccessful.test.js.snapshot   |  7998 ++++++++
 .../generic/toHave2xxStatus.test.js.snapshot  |  7998 ++++++++
 .../generic/toHave3xxStatus.test.js.snapshot  |  7998 ++++++++
 .../generic/toHave4xxStatus.test.js.snapshot  |  7998 ++++++++
 .../generic/toHave5xxStatus.test.js.snapshot  |  7998 ++++++++
 .../generic/toHaveStatus.test.js.snapshot     | 15234 ++++++++++++++++
 .../toHaveAcceptedStatus.test.js.snapshot     |    40 +
 .../toHaveBadGatewayStatus.test.js.snapshot   |    40 +
 .../toHaveBadRequestStatus.test.js.snapshot   |    40 +
 .../toHaveConflictStatus.test.js.snapshot     |    40 +
 .../toHaveCreatedStatus.test.js.snapshot      |    40 +
 ...veExpectationFailedStatus.test.js.snapshot |    40 +
 ...aveFailedDependencyStatus.test.js.snapshot |    40 +
 .../toHaveForbiddenStatus.test.js.snapshot    |    40 +
 ...oHaveGatewayTimeoutStatus.test.js.snapshot |    40 +
 .../toHaveGoneStatus.test.js.snapshot         |    40 +
 ...VersionNotSupportedStatus.test.js.snapshot |    40 +
 .../toHaveImATeapotStatus.test.js.snapshot    |    40 +
 ...ientSpaceOnResourceStatus.test.js.snapshot |    40 +
 ...InsufficientStorageStatus.test.js.snapshot |    40 +
 ...InternalServerErrorStatus.test.js.snapshot |    40 +
 ...oHaveLengthRequiredStatus.test.js.snapshot |    40 +
 .../toHaveLockedStatus.test.js.snapshot       |    40 +
 ...toHaveMethodFailureStatus.test.js.snapshot |    40 +
 ...aveMethodNotAllowedStatus.test.js.snapshot |    40 +
 ...eMisdirectedRequestStatus.test.js.snapshot |    40 +
 ...aveMovedPermanentlyStatus.test.js.snapshot |    40 +
 ...aveMovedTemporarilyStatus.test.js.snapshot |    40 +
 .../toHaveMultiStatusStatus.test.js.snapshot  |    40 +
 ...HaveMultipleChoicesStatus.test.js.snapshot |    40 +
 ...henticationRequiredStatus.test.js.snapshot |    40 +
 .../toHaveNoContentStatus.test.js.snapshot    |    38 +
 ...ritativeInformationStatus.test.js.snapshot |    40 +
 ...toHaveNotAcceptableStatus.test.js.snapshot |    40 +
 .../toHaveNotFoundStatus.test.js.snapshot     |    40 +
 ...oHaveNotImplementedStatus.test.js.snapshot |    40 +
 .../toHaveNotModifiedStatus.test.js.snapshot  |    40 +
 .../specific/toHaveOkStatus.test.js.snapshot  |    40 +
 ...oHavePartialContentStatus.test.js.snapshot |    40 +
 ...HavePaymentRequiredStatus.test.js.snapshot |    40 +
 ...vePermanentRedirectStatus.test.js.snapshot |    40 +
 ...ePreconditionFailedStatus.test.js.snapshot |    40 +
 ...reconditionRequiredStatus.test.js.snapshot |    40 +
 ...henticationRequiredStatus.test.js.snapshot |    40 +
 ...eaderFieldsTooLargeStatus.test.js.snapshot |    40 +
 ...oHaveRequestTimeoutStatus.test.js.snapshot |    40 +
 ...oHaveRequestTooLongStatus.test.js.snapshot |    40 +
 ...veRequestUriTooLongStatus.test.js.snapshot |    40 +
 ...RangeNotSatisfiableStatus.test.js.snapshot |    40 +
 .../toHaveResetContentStatus.test.js.snapshot |    40 +
 .../toHaveSeeOtherStatus.test.js.snapshot     |    40 +
 ...eServiceUnavailableStatus.test.js.snapshot |    40 +
 ...eSwitchingProtocolsStatus.test.js.snapshot |    38 +
 ...veTemporaryRedirectStatus.test.js.snapshot |    40 +
 ...HaveTooManyRequestsStatus.test.js.snapshot |    40 +
 .../toHaveUnauthorizedStatus.test.js.snapshot |    40 +
 ...ableForLegalReasonsStatus.test.js.snapshot |    40 +
 ...UnprocessableEntityStatus.test.js.snapshot |    40 +
 ...nsupportedMediaTypeStatus.test.js.snapshot |    40 +
 ...HaveUpgradeRequiredStatus.test.js.snapshot |    40 +
 .../toHaveUseProxyStatus.test.js.snapshot     |    40 +
 63 files changed, 58728 insertions(+)

diff --git a/test/matchers/data/toHaveBodyEquals.test.js.snapshot b/test/matchers/data/toHaveBodyEquals.test.js.snapshot
index 12391be..44d9af8 100644
--- a/test/matchers/data/toHaveBodyEquals.test.js.snapshot
+++ b/test/matchers/data/toHaveBodyEquals.test.js.snapshot
@@ -163,3 +163,169 @@ response is:
   }
 }
 `;
+
+exports[`(.not).toHaveBodyEquals > using got > .not.toHaveBodyEquals > should fail when the expected data match and body is json 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": "1", "b": 2, "c": true, "d": false, "e": null, "f": [], "g": {}}</color>
+But received:
+<red>{"a": "1", "b": 2, "c": true, "d": false, "e": null, "f": [], "g": {}}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "57",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .not.toHaveBodyEquals > should fail when the expected data match and body is json when using asymmetric matchers in the data 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>ObjectContaining {"b": Any<Number>, "c": true}</color>
+But received:
+<red>{"a": "1", "b": 2, "c": true, "d": false, "e": null, "f": [], "g": {}}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "57",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .not.toHaveBodyEquals > should fail when the expected data match and body is text 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>"Hello World"</color>
+But received:
+<red>"Hello World"</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "text/plain",
+    "content-length": "11",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .toHaveBodyEquals > should fail when the json data does not match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to have data:
+<green>- Expected  - 7</color>
+<red>+ Received  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": "1",</color>
+<green>-   "b": 2,</color>
+<green>-   "c": true,</color>
+<green>-   "d": false,</color>
+<green>-   "e": null,</color>
+<green>-   "f": Array [],</color>
+<green>-   "g": Object {},</color>
+<red>+   "f": 6,</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "7",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .toHaveBodyEquals > should fail when the json data does not match when using asymmetric matchers in the data 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to have data:
+<green>- Expected  - 2</color>
+<red>+ Received  + 8</color>
+
+<green>- ObjectContaining {</color>
+<green>-   "a": Any<Number>,</color>
+<red>+ Object {</color>
+<red>+   "a": "1",</color>
+<red>+   "b": 2,</color>
+<red>+   "c": true,</color>
+<red>+   "d": false,</color>
+<red>+   "e": null,</color>
+<red>+   "f": Array [],</color>
+<red>+   "g": Object {},</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "57",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .toHaveBodyEquals > should fail when the response body type does not match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to have data:
+Expected: <green>"Hello World"</color>
+Received: <red>{"f": 6}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "7",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyEquals > using got > .toHaveBodyEquals > should fail when the text data does not match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveDataEqualsTo(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to have data:
+Expected: <green>"Someone"</color>
+Received: <red>"Hello World"</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "text/plain",
+    "content-length": "11",
+    "connection": "keep-alive"
+  }
+}
+`;
diff --git a/test/matchers/data/toHaveBodyMatchObject.test.js.snapshot b/test/matchers/data/toHaveBodyMatchObject.test.js.snapshot
index 85e5c4c..aed17a0 100644
--- a/test/matchers/data/toHaveBodyMatchObject.test.js.snapshot
+++ b/test/matchers/data/toHaveBodyMatchObject.test.js.snapshot
@@ -1139,3 +1139,1145 @@ response is:
   }
 }
 `;
+
+exports[`(.not).toHaveBodyMatchObject > using got > .toHaveBodyMatchObject > should fail when the received response body have content type plain/text even though the data itself is JSON string  1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected response to have json body
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "plain/text",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > .toHaveBodyMatchObject > should fail when the received response body is plain/text data 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected response to have json body
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "plain/text",
+    "content-length": "11",
+    "connection": "keep-alive"
+  },
+  "body": "hello world"
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > response object does not have property and expected body has property undefined should match 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": undefined}</color>
+
+Received: <red>{}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is [0] and expected value is [-0] as -0 and 0 are the same value in JSON 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>[-0]</color>
+
+Received: <red>[0]</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "3",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is [1, 2] and expected value is [1, 2] 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>[1, 2]</color>
+
+Received: <red>[1, 2]</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "5",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is [] and expected value is [] 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>[]</color>
+
+Received: <red>[]</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b', c: 'd'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": "b", "c": "d"}</color>
+
+Received: <red>{"a": "b", "c": "d"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": "b"}</color>
+
+Received: <red>{"a": "b", "c": "d"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {a: 'b', t: {z: 'z'}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": "b", "t": {"z": "z"}}</color>
+
+Received: <red>{"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "37",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {t: {x: {r: 'r'}}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"t": {"x": {"r": "r"}}}</color>
+
+Received: <red>{"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "37",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 'b'} and expected value is Object.assign(Object.create(null), {a: 'b'}) 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": "b"}</color>
+
+Received: <red>{"a": "b"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "9",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: 1, c: 2} and expected value is {a: expect.any(Number)} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": Any<Number>}</color>
+
+Received: <red>{"a": 1, "c": 2}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "13",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: [3, 4, 5, 'v'], b: 'b'} and expected value is {a: [3, 4, 5, 'v']} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": [3, 4, 5, "v"]}</color>
+
+Received: <red>{"a": [3, 4, 5, "v"], "b": "b"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "25",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4, 5]} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": [3, 4, 5]}</color>
+
+Received: <red>{"a": [3, 4, 5], "b": "b"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "21",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: [{a: 'a', b: 'b'}]} and expected value is {a: [{a: 'a'}]} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": [{"a": "a"}]}</color>
+
+Received: <red>{"a": [{"a": "a", "b": "b"}]}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "25",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: null, b: 'b'} and expected value is {a: null} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": null}</color>
+
+Received: <red>{"a": null, "b": "b"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "18",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {a: {x: 'x', y: 'y'}} and expected value is {a: {x: expect.any(String)}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"a": {"x": Any<String>}}</color>
+
+Received: <red>{"a": {"x": "x", "y": "y"}}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "23",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {b: 'b'} and expected value is {} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{}</color>
+
+Received: <red>{"b": "b"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "9",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {message: 'bar'} and expected value is {message: 'bar'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{"message": "bar"}</color>
+
+Received: <red>{"message": "bar"}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Matching > should pass when the response body is {} and expected value is {} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+Expected request to not have data:
+<green>{}</color>
+
+Received: <red>{}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is [1, 2, 3] and expected value is [1, 2, 2] 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Array [</intensity>
+<dim>    1,</intensity>
+<dim>    2,</intensity>
+<green>-   2,</color>
+<red>+   3,</color>
+<dim>  ]</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "7",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is [1, 2, 3] and expected value is [2, 3, 1] 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Array [</intensity>
+<red>+   1,</color>
+<dim>    2,</intensity>
+<dim>    3,</intensity>
+<green>-   1,</color>
+<dim>  ]</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "7",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is [1, 2] and expected value is [1, 3] 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Array [</intensity>
+<dim>    1,</intensity>
+<green>-   3,</color>
+<red>+   2,</color>
+<dim>  ]</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "5",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is { a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers' } and expected value is {a: 'b', [Symbol.for('expect-http-client-matchers')]: 'expect-http-client-matchers'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 0</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": "b",</intensity>
+<green>-   Symbol(expect-http-client-matchers): "expect-http-client-matchers",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "85",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is { a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers' } and expected value is {a: 'c', [Symbol.for('expect-http-client-matchers')]: expect.any(String)} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 2</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": "c",</color>
+<green>-   Symbol(expect-http-client-matchers): Any<String>,</color>
+<red>+   "a": "b",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "85",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'a', c: 'd'} and expected value is {a: expect.any(Number)} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": Any<Number>,</color>
+<red>+   "a": "a",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers').toString()]: 'expect-http-client-matchers'} and expected value is {a: 'b', c: 'd', [Symbol.for('expect-http-client-matchers')]: 'expect-http-client-matchers'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 0</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": "b",</intensity>
+<dim>    "c": "d",</intensity>
+<green>-   Symbol(expect-http-client-matchers): "expect-http-client-matchers",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "85",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'b', c: 'd'} and expected value is {a: 'b!', c: 'd'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": "b!",</color>
+<red>+   "a": "b",</color>
+<dim>    "c": "d",</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'b', c: 'd'} and expected value is {e: 'b'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 2</color>
+
+<dim>  Object {</intensity>
+<green>-   "e": "b",</color>
+<red>+   "a": "b",</color>
+<red>+   "c": "d",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {a: 'b', t: {z: [3]}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 3</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": "b",</intensity>
+<dim>    "t": Object {</intensity>
+<green>-     "z": Array [</color>
+<green>-       3,</color>
+<green>-     ],</color>
+<red>+     "z": "z",</color>
+<dim>    },</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "37",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 'b', t: {x: {r: 'r'}, z: 'z'}} and expected value is {t: {l: {r: 'r'}}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 2</color>
+
+<dim>  Object {</intensity>
+<dim>    "t": Object {</intensity>
+<green>-     "l": Object {</color>
+<red>+     "x": Object {</color>
+<dim>        "r": "r",</intensity>
+<dim>      },</intensity>
+<red>+     "z": "z",</color>
+<dim>    },</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "37",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: 1, b: 1, c: 1, d: {e: {f: 555}}} and expected value is {d: {e: {f: 222}}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "d": Object {</intensity>
+<dim>      "e": Object {</intensity>
+<green>-       "f": 222,</color>
+<red>+       "f": 555,</color>
+<dim>      },</intensity>
+<dim>    },</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "39",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [3, 4, 'v'], b: 'b'} and expected value is {a: ['v']} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 0</color>
+<red>+ Received value  + 2</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": Array [</intensity>
+<red>+     3,</color>
+<red>+     4,</color>
+<dim>      "v",</intensity>
+<dim>    ],</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "23",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4, 5, 6]} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 0</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": Array [</intensity>
+<dim>      3,</intensity>
+<dim>      4,</intensity>
+<dim>      5,</intensity>
+<green>-     6,</color>
+<dim>    ],</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "21",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: [3, 4]} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 0</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": Array [</intensity>
+<dim>      3,</intensity>
+<dim>      4,</intensity>
+<red>+     5,</color>
+<dim>    ],</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "21",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: {b: 4}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 3</color>
+<red>+ Received value  + 5</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": Object {</color>
+<green>-     "b": 4,</color>
+<green>-   },</color>
+<red>+   "a": Array [</color>
+<red>+     3,</color>
+<red>+     4,</color>
+<red>+     5,</color>
+<red>+   ],</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "21",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [3, 4, 5], b: 'b'} and expected value is {a: {b: expect.any(String)}} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 3</color>
+<red>+ Received value  + 5</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": Object {</color>
+<green>-     "b": Any<String>,</color>
+<green>-   },</color>
+<red>+   "a": Array [</color>
+<red>+     3,</color>
+<red>+     4,</color>
+<red>+     5,</color>
+<red>+   ],</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "21",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: [{a: 'a', b: 'b'}]} and expected value is {a: [{a: 'c'}]} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": Array [</intensity>
+<dim>      Object {</intensity>
+<green>-       "a": "c",</color>
+<red>+       "a": "a",</color>
+<dim>      },</intensity>
+<dim>    ],</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "25",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: new Date('2015-11-30').toISOString(), b: 'b'} and expected value is {a: new Date('2015-10-10')} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": 2015-10-10T00:00:00.000Z,</color>
+<red>+   "a": "2015-11-30T00:00:00.000Z",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "40",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: null, b: 'b'} and expected value is {a: '4'} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": "4",</color>
+<red>+   "a": null,</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "18",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: undefined, b: 'b', c: 'c'} and expected value is new Sub() 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 4</color>
+
+<green>- Sub {}</color>
+<red>+ Object {</color>
+<red>+   "b": "b",</color>
+<red>+   "c": "c",</color>
+<red>+ }</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "17",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: undefined, b: 'b'} and expected value is new Foo() as cant match because classes are not valid JSON value 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 3</color>
+
+<green>- Foo {}</color>
+<red>+ Object {</color>
+<red>+   "b": "b",</color>
+<red>+ }</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "9",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {a: {}} and expected value is {a: new Set([])} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": Set {},</color>
+<red>+   "a": Object {},</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "8",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {c: 'd'} and expected value is Object.assign(Object.create(null), {a: 'b'}) 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<green>-   "a": "b",</color>
+<red>+   "c": "d",</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "9",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {d: 4} and expected value is withDefineProperty(new Sub(), 'd', 4) 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 3</color>
+
+<green>- Sub {}</color>
+<red>+ Object {</color>
+<red>+   "d": 4,</color>
+<red>+ }</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "7",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > Not matching > should not match when the response body is {} and expected value is  {a: null} 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 3</color>
+<red>+ Received value  + 1</color>
+
+<green>- Object {</color>
+<green>-   "a": null,</color>
+<green>- }</color>
+<red>+ Object {}</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > circular references > should not pass when expected object contain circular references as its not possible in response object 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": "hello",</intensity>
+<green>-   "ref": [Circular],</color>
+<red>+   "ref": Object {},</color>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "22",
+    "connection": "keep-alive"
+  }
+}
+`;
+
+exports[`(.not).toHaveBodyMatchObject > using got > toMatchObject tests > circular references > should not pass when expected object contain transitive circular references as its not possible in response object 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBodyMatchObject(</intensity><green>expected</color><dim>)</intensity>
+
+<green>- Expected value  - 1</color>
+<red>+ Received value  + 1</color>
+
+<dim>  Object {</intensity>
+<dim>    "a": "hello",</intensity>
+<dim>    "nestedObj": Object {</intensity>
+<green>-     "parentObj": [Circular],</color>
+<red>+     "parentObj": Object {},</color>
+<dim>    },</intensity>
+<dim>  }</intensity>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/body",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "42",
+    "connection": "keep-alive"
+  }
+}
+`;
diff --git a/test/matchers/status/generic/toBeSuccessful.test.js.snapshot b/test/matchers/status/generic/toBeSuccessful.test.js.snapshot
index d22f9e6..db24bb7 100644
--- a/test/matchers/status/generic/toBeSuccessful.test.js.snapshot
+++ b/test/matchers/status/generic/toBeSuccessful.test.js.snapshot
@@ -7995,3 +7995,8001 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .not.toBeSuccessful > status 200 to 299 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toBeSuccessful()</intensity>
+
+Expected status code to not be successful received:
+  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toBeSuccessful > using got > .toBeSuccessful > status 300 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toBeSuccessful()</intensity>
+
+Expected status code to be successful received:
+  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/generic/toHave2xxStatus.test.js.snapshot b/test/matchers/status/generic/toHave2xxStatus.test.js.snapshot
index b698f25..3020e2a 100644
--- a/test/matchers/status/generic/toHave2xxStatus.test.js.snapshot
+++ b/test/matchers/status/generic/toHave2xxStatus.test.js.snapshot
@@ -7995,3 +7995,8001 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .not.toHave2xxStatus > status 200 to 299 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave2xxStatus()</intensity>
+
+Expected status code to not be between 200 and 299 received:
+  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave2xxStatus > using got > .toHave2xxStatus > status 300 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave2xxStatus()</intensity>
+
+Expected status code to be between 200 and 299 received:
+  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/generic/toHave3xxStatus.test.js.snapshot b/test/matchers/status/generic/toHave3xxStatus.test.js.snapshot
index 358bfb7..6d98d17 100644
--- a/test/matchers/status/generic/toHave3xxStatus.test.js.snapshot
+++ b/test/matchers/status/generic/toHave3xxStatus.test.js.snapshot
@@ -7995,3 +7995,8001 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .not.toHave3xxStatus > status 300 to 399 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 300 and 399 received:
+  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave3xxStatus > using got > .toHave3xxStatus > status 200 to 299 and 400 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 300 and 399 received:
+  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/generic/toHave4xxStatus.test.js.snapshot b/test/matchers/status/generic/toHave4xxStatus.test.js.snapshot
index 0950a2b..7a91fcd 100644
--- a/test/matchers/status/generic/toHave4xxStatus.test.js.snapshot
+++ b/test/matchers/status/generic/toHave4xxStatus.test.js.snapshot
@@ -7995,3 +7995,8001 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .not.toHave4xxStatus > status 400 to 499 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 400 and 499 received:
+  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave4xxStatus > using got > .toHave4xxStatus > status 200 to 399 and 500 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 400 and 499 received:
+  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/generic/toHave5xxStatus.test.js.snapshot b/test/matchers/status/generic/toHave5xxStatus.test.js.snapshot
index da56714..d10dd9f 100644
--- a/test/matchers/status/generic/toHave5xxStatus.test.js.snapshot
+++ b/test/matchers/status/generic/toHave5xxStatus.test.js.snapshot
@@ -7995,3 +7995,8001 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .not.toHave5xxStatus > status 500 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHave3xxStatus()</intensity>
+
+Expected status code to not be between 500 and 599 received:
+  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHave5xxStatus > using got > .toHave5xxStatus > status 200 to 499 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHave3xxStatus()</intensity>
+
+Expected status code to be between 500 and 599 received:
+  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/generic/toHaveStatus.test.js.snapshot b/test/matchers/status/generic/toHaveStatus.test.js.snapshot
index 441653c..d6d36ae 100644
--- a/test/matchers/status/generic/toHaveStatus.test.js.snapshot
+++ b/test/matchers/status/generic/toHaveStatus.test.js.snapshot
@@ -15231,3 +15231,15237 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > fails when given incorrect asymmetric matcher as status 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>Any<Number></color><dim>)</intensity>
+
+Expected status code to not be Any<Number> received:  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 200 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>200</color><dim>)</intensity>
+
+Expected status code to not be 200 received:  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 201 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>201</color><dim>)</intensity>
+
+Expected status code to not be 201 received:  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 202 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>202</color><dim>)</intensity>
+
+Expected status code to not be 202 received:  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 203 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>203</color><dim>)</intensity>
+
+Expected status code to not be 203 received:  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 204 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>204</color><dim>)</intensity>
+
+Expected status code to not be 204 received:  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 205 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>205</color><dim>)</intensity>
+
+Expected status code to not be 205 received:  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 206 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>206</color><dim>)</intensity>
+
+Expected status code to not be 206 received:  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 207 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>207</color><dim>)</intensity>
+
+Expected status code to not be 207 received:  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 208 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>208</color><dim>)</intensity>
+
+Expected status code to not be 208 received:  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 209 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>209</color><dim>)</intensity>
+
+Expected status code to not be 209 received:  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 210 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>210</color><dim>)</intensity>
+
+Expected status code to not be 210 received:  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 211 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>211</color><dim>)</intensity>
+
+Expected status code to not be 211 received:  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 212 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>212</color><dim>)</intensity>
+
+Expected status code to not be 212 received:  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 213 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>213</color><dim>)</intensity>
+
+Expected status code to not be 213 received:  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 214 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>214</color><dim>)</intensity>
+
+Expected status code to not be 214 received:  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 215 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>215</color><dim>)</intensity>
+
+Expected status code to not be 215 received:  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 216 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>216</color><dim>)</intensity>
+
+Expected status code to not be 216 received:  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 217 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>217</color><dim>)</intensity>
+
+Expected status code to not be 217 received:  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 218 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>218</color><dim>)</intensity>
+
+Expected status code to not be 218 received:  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 219 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>219</color><dim>)</intensity>
+
+Expected status code to not be 219 received:  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 220 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>220</color><dim>)</intensity>
+
+Expected status code to not be 220 received:  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 221 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>221</color><dim>)</intensity>
+
+Expected status code to not be 221 received:  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 222 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>222</color><dim>)</intensity>
+
+Expected status code to not be 222 received:  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 223 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>223</color><dim>)</intensity>
+
+Expected status code to not be 223 received:  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 224 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>224</color><dim>)</intensity>
+
+Expected status code to not be 224 received:  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 225 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>225</color><dim>)</intensity>
+
+Expected status code to not be 225 received:  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 226 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>226</color><dim>)</intensity>
+
+Expected status code to not be 226 received:  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 227 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>227</color><dim>)</intensity>
+
+Expected status code to not be 227 received:  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 228 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>228</color><dim>)</intensity>
+
+Expected status code to not be 228 received:  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 229 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>229</color><dim>)</intensity>
+
+Expected status code to not be 229 received:  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 230 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>230</color><dim>)</intensity>
+
+Expected status code to not be 230 received:  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 231 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>231</color><dim>)</intensity>
+
+Expected status code to not be 231 received:  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 232 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>232</color><dim>)</intensity>
+
+Expected status code to not be 232 received:  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 233 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>233</color><dim>)</intensity>
+
+Expected status code to not be 233 received:  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 234 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>234</color><dim>)</intensity>
+
+Expected status code to not be 234 received:  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 235 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>235</color><dim>)</intensity>
+
+Expected status code to not be 235 received:  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 236 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>236</color><dim>)</intensity>
+
+Expected status code to not be 236 received:  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 237 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>237</color><dim>)</intensity>
+
+Expected status code to not be 237 received:  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 238 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>238</color><dim>)</intensity>
+
+Expected status code to not be 238 received:  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 239 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>239</color><dim>)</intensity>
+
+Expected status code to not be 239 received:  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 240 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>240</color><dim>)</intensity>
+
+Expected status code to not be 240 received:  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 241 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>241</color><dim>)</intensity>
+
+Expected status code to not be 241 received:  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 242 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>242</color><dim>)</intensity>
+
+Expected status code to not be 242 received:  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 243 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>243</color><dim>)</intensity>
+
+Expected status code to not be 243 received:  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 244 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>244</color><dim>)</intensity>
+
+Expected status code to not be 244 received:  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 245 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>245</color><dim>)</intensity>
+
+Expected status code to not be 245 received:  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 246 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>246</color><dim>)</intensity>
+
+Expected status code to not be 246 received:  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 247 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>247</color><dim>)</intensity>
+
+Expected status code to not be 247 received:  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 248 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>248</color><dim>)</intensity>
+
+Expected status code to not be 248 received:  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 249 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>249</color><dim>)</intensity>
+
+Expected status code to not be 249 received:  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 250 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>250</color><dim>)</intensity>
+
+Expected status code to not be 250 received:  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 251 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>251</color><dim>)</intensity>
+
+Expected status code to not be 251 received:  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 252 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>252</color><dim>)</intensity>
+
+Expected status code to not be 252 received:  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 253 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>253</color><dim>)</intensity>
+
+Expected status code to not be 253 received:  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 254 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>254</color><dim>)</intensity>
+
+Expected status code to not be 254 received:  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 255 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>255</color><dim>)</intensity>
+
+Expected status code to not be 255 received:  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 256 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>256</color><dim>)</intensity>
+
+Expected status code to not be 256 received:  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 257 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>257</color><dim>)</intensity>
+
+Expected status code to not be 257 received:  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 258 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>258</color><dim>)</intensity>
+
+Expected status code to not be 258 received:  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 259 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>259</color><dim>)</intensity>
+
+Expected status code to not be 259 received:  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 260 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>260</color><dim>)</intensity>
+
+Expected status code to not be 260 received:  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 261 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>261</color><dim>)</intensity>
+
+Expected status code to not be 261 received:  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 262 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>262</color><dim>)</intensity>
+
+Expected status code to not be 262 received:  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 263 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>263</color><dim>)</intensity>
+
+Expected status code to not be 263 received:  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 264 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>264</color><dim>)</intensity>
+
+Expected status code to not be 264 received:  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 265 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>265</color><dim>)</intensity>
+
+Expected status code to not be 265 received:  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 266 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>266</color><dim>)</intensity>
+
+Expected status code to not be 266 received:  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 267 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>267</color><dim>)</intensity>
+
+Expected status code to not be 267 received:  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 268 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>268</color><dim>)</intensity>
+
+Expected status code to not be 268 received:  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 269 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>269</color><dim>)</intensity>
+
+Expected status code to not be 269 received:  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 270 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>270</color><dim>)</intensity>
+
+Expected status code to not be 270 received:  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 271 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>271</color><dim>)</intensity>
+
+Expected status code to not be 271 received:  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 272 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>272</color><dim>)</intensity>
+
+Expected status code to not be 272 received:  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 273 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>273</color><dim>)</intensity>
+
+Expected status code to not be 273 received:  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 274 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>274</color><dim>)</intensity>
+
+Expected status code to not be 274 received:  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 275 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>275</color><dim>)</intensity>
+
+Expected status code to not be 275 received:  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 276 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>276</color><dim>)</intensity>
+
+Expected status code to not be 276 received:  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 277 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>277</color><dim>)</intensity>
+
+Expected status code to not be 277 received:  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 278 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>278</color><dim>)</intensity>
+
+Expected status code to not be 278 received:  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 279 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>279</color><dim>)</intensity>
+
+Expected status code to not be 279 received:  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 280 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>280</color><dim>)</intensity>
+
+Expected status code to not be 280 received:  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 281 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>281</color><dim>)</intensity>
+
+Expected status code to not be 281 received:  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 282 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>282</color><dim>)</intensity>
+
+Expected status code to not be 282 received:  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 283 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>283</color><dim>)</intensity>
+
+Expected status code to not be 283 received:  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 284 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>284</color><dim>)</intensity>
+
+Expected status code to not be 284 received:  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 285 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>285</color><dim>)</intensity>
+
+Expected status code to not be 285 received:  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 286 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>286</color><dim>)</intensity>
+
+Expected status code to not be 286 received:  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 287 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>287</color><dim>)</intensity>
+
+Expected status code to not be 287 received:  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 288 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>288</color><dim>)</intensity>
+
+Expected status code to not be 288 received:  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 289 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>289</color><dim>)</intensity>
+
+Expected status code to not be 289 received:  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 290 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>290</color><dim>)</intensity>
+
+Expected status code to not be 290 received:  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 291 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>291</color><dim>)</intensity>
+
+Expected status code to not be 291 received:  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 292 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>292</color><dim>)</intensity>
+
+Expected status code to not be 292 received:  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 293 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>293</color><dim>)</intensity>
+
+Expected status code to not be 293 received:  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 294 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>294</color><dim>)</intensity>
+
+Expected status code to not be 294 received:  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 295 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>295</color><dim>)</intensity>
+
+Expected status code to not be 295 received:  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 296 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>296</color><dim>)</intensity>
+
+Expected status code to not be 296 received:  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 297 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>297</color><dim>)</intensity>
+
+Expected status code to not be 297 received:  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 298 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>298</color><dim>)</intensity>
+
+Expected status code to not be 298 received:  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 299 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>299</color><dim>)</intensity>
+
+Expected status code to not be 299 received:  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 300 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>300</color><dim>)</intensity>
+
+Expected status code to not be 300 received:  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 301 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>301</color><dim>)</intensity>
+
+Expected status code to not be 301 received:  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 302 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>302</color><dim>)</intensity>
+
+Expected status code to not be 302 received:  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 303 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>303</color><dim>)</intensity>
+
+Expected status code to not be 303 received:  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 304 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>304</color><dim>)</intensity>
+
+Expected status code to not be 304 received:  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 305 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>305</color><dim>)</intensity>
+
+Expected status code to not be 305 received:  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 306 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>306</color><dim>)</intensity>
+
+Expected status code to not be 306 received:  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 307 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>307</color><dim>)</intensity>
+
+Expected status code to not be 307 received:  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 308 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>308</color><dim>)</intensity>
+
+Expected status code to not be 308 received:  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 309 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>309</color><dim>)</intensity>
+
+Expected status code to not be 309 received:  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 310 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>310</color><dim>)</intensity>
+
+Expected status code to not be 310 received:  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 311 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>311</color><dim>)</intensity>
+
+Expected status code to not be 311 received:  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 312 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>312</color><dim>)</intensity>
+
+Expected status code to not be 312 received:  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 313 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>313</color><dim>)</intensity>
+
+Expected status code to not be 313 received:  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 314 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>314</color><dim>)</intensity>
+
+Expected status code to not be 314 received:  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 315 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>315</color><dim>)</intensity>
+
+Expected status code to not be 315 received:  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 316 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>316</color><dim>)</intensity>
+
+Expected status code to not be 316 received:  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 317 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>317</color><dim>)</intensity>
+
+Expected status code to not be 317 received:  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 318 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>318</color><dim>)</intensity>
+
+Expected status code to not be 318 received:  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 319 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>319</color><dim>)</intensity>
+
+Expected status code to not be 319 received:  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 320 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>320</color><dim>)</intensity>
+
+Expected status code to not be 320 received:  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 321 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>321</color><dim>)</intensity>
+
+Expected status code to not be 321 received:  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 322 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>322</color><dim>)</intensity>
+
+Expected status code to not be 322 received:  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 323 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>323</color><dim>)</intensity>
+
+Expected status code to not be 323 received:  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 324 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>324</color><dim>)</intensity>
+
+Expected status code to not be 324 received:  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 325 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>325</color><dim>)</intensity>
+
+Expected status code to not be 325 received:  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 326 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>326</color><dim>)</intensity>
+
+Expected status code to not be 326 received:  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 327 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>327</color><dim>)</intensity>
+
+Expected status code to not be 327 received:  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 328 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>328</color><dim>)</intensity>
+
+Expected status code to not be 328 received:  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 329 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>329</color><dim>)</intensity>
+
+Expected status code to not be 329 received:  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 330 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>330</color><dim>)</intensity>
+
+Expected status code to not be 330 received:  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 331 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>331</color><dim>)</intensity>
+
+Expected status code to not be 331 received:  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 332 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>332</color><dim>)</intensity>
+
+Expected status code to not be 332 received:  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 333 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>333</color><dim>)</intensity>
+
+Expected status code to not be 333 received:  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 334 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>334</color><dim>)</intensity>
+
+Expected status code to not be 334 received:  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 335 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>335</color><dim>)</intensity>
+
+Expected status code to not be 335 received:  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 336 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>336</color><dim>)</intensity>
+
+Expected status code to not be 336 received:  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 337 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>337</color><dim>)</intensity>
+
+Expected status code to not be 337 received:  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 338 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>338</color><dim>)</intensity>
+
+Expected status code to not be 338 received:  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 339 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>339</color><dim>)</intensity>
+
+Expected status code to not be 339 received:  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 340 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>340</color><dim>)</intensity>
+
+Expected status code to not be 340 received:  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 341 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>341</color><dim>)</intensity>
+
+Expected status code to not be 341 received:  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 342 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>342</color><dim>)</intensity>
+
+Expected status code to not be 342 received:  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 343 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>343</color><dim>)</intensity>
+
+Expected status code to not be 343 received:  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 344 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>344</color><dim>)</intensity>
+
+Expected status code to not be 344 received:  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 345 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>345</color><dim>)</intensity>
+
+Expected status code to not be 345 received:  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 346 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>346</color><dim>)</intensity>
+
+Expected status code to not be 346 received:  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 347 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>347</color><dim>)</intensity>
+
+Expected status code to not be 347 received:  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 348 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>348</color><dim>)</intensity>
+
+Expected status code to not be 348 received:  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 349 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>349</color><dim>)</intensity>
+
+Expected status code to not be 349 received:  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 350 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>350</color><dim>)</intensity>
+
+Expected status code to not be 350 received:  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 351 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>351</color><dim>)</intensity>
+
+Expected status code to not be 351 received:  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 352 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>352</color><dim>)</intensity>
+
+Expected status code to not be 352 received:  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 353 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>353</color><dim>)</intensity>
+
+Expected status code to not be 353 received:  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 354 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>354</color><dim>)</intensity>
+
+Expected status code to not be 354 received:  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 355 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>355</color><dim>)</intensity>
+
+Expected status code to not be 355 received:  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 356 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>356</color><dim>)</intensity>
+
+Expected status code to not be 356 received:  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 357 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>357</color><dim>)</intensity>
+
+Expected status code to not be 357 received:  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 358 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>358</color><dim>)</intensity>
+
+Expected status code to not be 358 received:  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 359 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>359</color><dim>)</intensity>
+
+Expected status code to not be 359 received:  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 360 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>360</color><dim>)</intensity>
+
+Expected status code to not be 360 received:  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 361 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>361</color><dim>)</intensity>
+
+Expected status code to not be 361 received:  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 362 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>362</color><dim>)</intensity>
+
+Expected status code to not be 362 received:  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 363 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>363</color><dim>)</intensity>
+
+Expected status code to not be 363 received:  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 364 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>364</color><dim>)</intensity>
+
+Expected status code to not be 364 received:  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 365 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>365</color><dim>)</intensity>
+
+Expected status code to not be 365 received:  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 366 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>366</color><dim>)</intensity>
+
+Expected status code to not be 366 received:  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 367 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>367</color><dim>)</intensity>
+
+Expected status code to not be 367 received:  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 368 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>368</color><dim>)</intensity>
+
+Expected status code to not be 368 received:  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 369 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>369</color><dim>)</intensity>
+
+Expected status code to not be 369 received:  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 370 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>370</color><dim>)</intensity>
+
+Expected status code to not be 370 received:  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 371 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>371</color><dim>)</intensity>
+
+Expected status code to not be 371 received:  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 372 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>372</color><dim>)</intensity>
+
+Expected status code to not be 372 received:  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 373 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>373</color><dim>)</intensity>
+
+Expected status code to not be 373 received:  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 374 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>374</color><dim>)</intensity>
+
+Expected status code to not be 374 received:  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 375 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>375</color><dim>)</intensity>
+
+Expected status code to not be 375 received:  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 376 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>376</color><dim>)</intensity>
+
+Expected status code to not be 376 received:  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 377 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>377</color><dim>)</intensity>
+
+Expected status code to not be 377 received:  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 378 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>378</color><dim>)</intensity>
+
+Expected status code to not be 378 received:  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 379 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>379</color><dim>)</intensity>
+
+Expected status code to not be 379 received:  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 380 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>380</color><dim>)</intensity>
+
+Expected status code to not be 380 received:  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 381 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>381</color><dim>)</intensity>
+
+Expected status code to not be 381 received:  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 382 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>382</color><dim>)</intensity>
+
+Expected status code to not be 382 received:  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 383 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>383</color><dim>)</intensity>
+
+Expected status code to not be 383 received:  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 384 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>384</color><dim>)</intensity>
+
+Expected status code to not be 384 received:  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 385 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>385</color><dim>)</intensity>
+
+Expected status code to not be 385 received:  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 386 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>386</color><dim>)</intensity>
+
+Expected status code to not be 386 received:  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 387 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>387</color><dim>)</intensity>
+
+Expected status code to not be 387 received:  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 388 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>388</color><dim>)</intensity>
+
+Expected status code to not be 388 received:  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 389 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>389</color><dim>)</intensity>
+
+Expected status code to not be 389 received:  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 390 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>390</color><dim>)</intensity>
+
+Expected status code to not be 390 received:  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 391 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>391</color><dim>)</intensity>
+
+Expected status code to not be 391 received:  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 392 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>392</color><dim>)</intensity>
+
+Expected status code to not be 392 received:  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 393 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>393</color><dim>)</intensity>
+
+Expected status code to not be 393 received:  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 394 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>394</color><dim>)</intensity>
+
+Expected status code to not be 394 received:  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 395 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>395</color><dim>)</intensity>
+
+Expected status code to not be 395 received:  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 396 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>396</color><dim>)</intensity>
+
+Expected status code to not be 396 received:  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 397 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>397</color><dim>)</intensity>
+
+Expected status code to not be 397 received:  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 398 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>398</color><dim>)</intensity>
+
+Expected status code to not be 398 received:  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 399 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>399</color><dim>)</intensity>
+
+Expected status code to not be 399 received:  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 400 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>400</color><dim>)</intensity>
+
+Expected status code to not be 400 received:  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 401 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>401</color><dim>)</intensity>
+
+Expected status code to not be 401 received:  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 402 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>402</color><dim>)</intensity>
+
+Expected status code to not be 402 received:  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 403 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>403</color><dim>)</intensity>
+
+Expected status code to not be 403 received:  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 404 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>404</color><dim>)</intensity>
+
+Expected status code to not be 404 received:  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 405 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>405</color><dim>)</intensity>
+
+Expected status code to not be 405 received:  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 406 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>406</color><dim>)</intensity>
+
+Expected status code to not be 406 received:  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 407 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>407</color><dim>)</intensity>
+
+Expected status code to not be 407 received:  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 408 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>408</color><dim>)</intensity>
+
+Expected status code to not be 408 received:  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 409 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>409</color><dim>)</intensity>
+
+Expected status code to not be 409 received:  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 410 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>410</color><dim>)</intensity>
+
+Expected status code to not be 410 received:  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 411 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>411</color><dim>)</intensity>
+
+Expected status code to not be 411 received:  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 412 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>412</color><dim>)</intensity>
+
+Expected status code to not be 412 received:  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 413 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>413</color><dim>)</intensity>
+
+Expected status code to not be 413 received:  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 414 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>414</color><dim>)</intensity>
+
+Expected status code to not be 414 received:  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 415 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>415</color><dim>)</intensity>
+
+Expected status code to not be 415 received:  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 416 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>416</color><dim>)</intensity>
+
+Expected status code to not be 416 received:  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 417 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>417</color><dim>)</intensity>
+
+Expected status code to not be 417 received:  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 418 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>418</color><dim>)</intensity>
+
+Expected status code to not be 418 received:  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 419 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>419</color><dim>)</intensity>
+
+Expected status code to not be 419 received:  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 420 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>420</color><dim>)</intensity>
+
+Expected status code to not be 420 received:  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 421 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>421</color><dim>)</intensity>
+
+Expected status code to not be 421 received:  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 422 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>422</color><dim>)</intensity>
+
+Expected status code to not be 422 received:  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 423 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>423</color><dim>)</intensity>
+
+Expected status code to not be 423 received:  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 424 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>424</color><dim>)</intensity>
+
+Expected status code to not be 424 received:  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 425 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>425</color><dim>)</intensity>
+
+Expected status code to not be 425 received:  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 426 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>426</color><dim>)</intensity>
+
+Expected status code to not be 426 received:  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 427 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>427</color><dim>)</intensity>
+
+Expected status code to not be 427 received:  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 428 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>428</color><dim>)</intensity>
+
+Expected status code to not be 428 received:  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 429 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>429</color><dim>)</intensity>
+
+Expected status code to not be 429 received:  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 430 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>430</color><dim>)</intensity>
+
+Expected status code to not be 430 received:  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 431 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>431</color><dim>)</intensity>
+
+Expected status code to not be 431 received:  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 432 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>432</color><dim>)</intensity>
+
+Expected status code to not be 432 received:  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 433 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>433</color><dim>)</intensity>
+
+Expected status code to not be 433 received:  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 434 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>434</color><dim>)</intensity>
+
+Expected status code to not be 434 received:  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 435 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>435</color><dim>)</intensity>
+
+Expected status code to not be 435 received:  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 436 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>436</color><dim>)</intensity>
+
+Expected status code to not be 436 received:  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 437 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>437</color><dim>)</intensity>
+
+Expected status code to not be 437 received:  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 438 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>438</color><dim>)</intensity>
+
+Expected status code to not be 438 received:  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 439 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>439</color><dim>)</intensity>
+
+Expected status code to not be 439 received:  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 440 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>440</color><dim>)</intensity>
+
+Expected status code to not be 440 received:  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 441 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>441</color><dim>)</intensity>
+
+Expected status code to not be 441 received:  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 442 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>442</color><dim>)</intensity>
+
+Expected status code to not be 442 received:  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 443 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>443</color><dim>)</intensity>
+
+Expected status code to not be 443 received:  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 444 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>444</color><dim>)</intensity>
+
+Expected status code to not be 444 received:  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 445 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>445</color><dim>)</intensity>
+
+Expected status code to not be 445 received:  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 446 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>446</color><dim>)</intensity>
+
+Expected status code to not be 446 received:  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 447 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>447</color><dim>)</intensity>
+
+Expected status code to not be 447 received:  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 448 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>448</color><dim>)</intensity>
+
+Expected status code to not be 448 received:  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 449 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>449</color><dim>)</intensity>
+
+Expected status code to not be 449 received:  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 450 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>450</color><dim>)</intensity>
+
+Expected status code to not be 450 received:  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 451 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>451</color><dim>)</intensity>
+
+Expected status code to not be 451 received:  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 452 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>452</color><dim>)</intensity>
+
+Expected status code to not be 452 received:  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 453 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>453</color><dim>)</intensity>
+
+Expected status code to not be 453 received:  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 454 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>454</color><dim>)</intensity>
+
+Expected status code to not be 454 received:  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 455 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>455</color><dim>)</intensity>
+
+Expected status code to not be 455 received:  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 456 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>456</color><dim>)</intensity>
+
+Expected status code to not be 456 received:  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 457 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>457</color><dim>)</intensity>
+
+Expected status code to not be 457 received:  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 458 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>458</color><dim>)</intensity>
+
+Expected status code to not be 458 received:  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 459 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>459</color><dim>)</intensity>
+
+Expected status code to not be 459 received:  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 460 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>460</color><dim>)</intensity>
+
+Expected status code to not be 460 received:  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 461 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>461</color><dim>)</intensity>
+
+Expected status code to not be 461 received:  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 462 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>462</color><dim>)</intensity>
+
+Expected status code to not be 462 received:  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 463 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>463</color><dim>)</intensity>
+
+Expected status code to not be 463 received:  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 464 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>464</color><dim>)</intensity>
+
+Expected status code to not be 464 received:  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 465 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>465</color><dim>)</intensity>
+
+Expected status code to not be 465 received:  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 466 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>466</color><dim>)</intensity>
+
+Expected status code to not be 466 received:  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 467 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>467</color><dim>)</intensity>
+
+Expected status code to not be 467 received:  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 468 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>468</color><dim>)</intensity>
+
+Expected status code to not be 468 received:  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 469 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>469</color><dim>)</intensity>
+
+Expected status code to not be 469 received:  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 470 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>470</color><dim>)</intensity>
+
+Expected status code to not be 470 received:  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 471 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>471</color><dim>)</intensity>
+
+Expected status code to not be 471 received:  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 472 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>472</color><dim>)</intensity>
+
+Expected status code to not be 472 received:  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 473 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>473</color><dim>)</intensity>
+
+Expected status code to not be 473 received:  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 474 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>474</color><dim>)</intensity>
+
+Expected status code to not be 474 received:  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 475 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>475</color><dim>)</intensity>
+
+Expected status code to not be 475 received:  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 476 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>476</color><dim>)</intensity>
+
+Expected status code to not be 476 received:  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 477 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>477</color><dim>)</intensity>
+
+Expected status code to not be 477 received:  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 478 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>478</color><dim>)</intensity>
+
+Expected status code to not be 478 received:  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 479 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>479</color><dim>)</intensity>
+
+Expected status code to not be 479 received:  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 480 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>480</color><dim>)</intensity>
+
+Expected status code to not be 480 received:  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 481 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>481</color><dim>)</intensity>
+
+Expected status code to not be 481 received:  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 482 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>482</color><dim>)</intensity>
+
+Expected status code to not be 482 received:  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 483 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>483</color><dim>)</intensity>
+
+Expected status code to not be 483 received:  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 484 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>484</color><dim>)</intensity>
+
+Expected status code to not be 484 received:  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 485 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>485</color><dim>)</intensity>
+
+Expected status code to not be 485 received:  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 486 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>486</color><dim>)</intensity>
+
+Expected status code to not be 486 received:  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 487 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>487</color><dim>)</intensity>
+
+Expected status code to not be 487 received:  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 488 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>488</color><dim>)</intensity>
+
+Expected status code to not be 488 received:  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 489 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>489</color><dim>)</intensity>
+
+Expected status code to not be 489 received:  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 490 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>490</color><dim>)</intensity>
+
+Expected status code to not be 490 received:  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 491 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>491</color><dim>)</intensity>
+
+Expected status code to not be 491 received:  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 492 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>492</color><dim>)</intensity>
+
+Expected status code to not be 492 received:  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 493 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>493</color><dim>)</intensity>
+
+Expected status code to not be 493 received:  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 494 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>494</color><dim>)</intensity>
+
+Expected status code to not be 494 received:  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 495 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>495</color><dim>)</intensity>
+
+Expected status code to not be 495 received:  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 496 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>496</color><dim>)</intensity>
+
+Expected status code to not be 496 received:  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 497 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>497</color><dim>)</intensity>
+
+Expected status code to not be 497 received:  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 498 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>498</color><dim>)</intensity>
+
+Expected status code to not be 498 received:  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 499 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>499</color><dim>)</intensity>
+
+Expected status code to not be 499 received:  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 500 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>500</color><dim>)</intensity>
+
+Expected status code to not be 500 received:  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 501 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>501</color><dim>)</intensity>
+
+Expected status code to not be 501 received:  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 502 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>502</color><dim>)</intensity>
+
+Expected status code to not be 502 received:  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 503 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>503</color><dim>)</intensity>
+
+Expected status code to not be 503 received:  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 504 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>504</color><dim>)</intensity>
+
+Expected status code to not be 504 received:  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 505 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>505</color><dim>)</intensity>
+
+Expected status code to not be 505 received:  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 506 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>506</color><dim>)</intensity>
+
+Expected status code to not be 506 received:  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 507 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>507</color><dim>)</intensity>
+
+Expected status code to not be 507 received:  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 508 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>508</color><dim>)</intensity>
+
+Expected status code to not be 508 received:  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 509 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>509</color><dim>)</intensity>
+
+Expected status code to not be 509 received:  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 510 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>510</color><dim>)</intensity>
+
+Expected status code to not be 510 received:  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 511 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>511</color><dim>)</intensity>
+
+Expected status code to not be 511 received:  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 512 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>512</color><dim>)</intensity>
+
+Expected status code to not be 512 received:  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 513 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>513</color><dim>)</intensity>
+
+Expected status code to not be 513 received:  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 514 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>514</color><dim>)</intensity>
+
+Expected status code to not be 514 received:  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 515 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>515</color><dim>)</intensity>
+
+Expected status code to not be 515 received:  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 516 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>516</color><dim>)</intensity>
+
+Expected status code to not be 516 received:  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 517 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>517</color><dim>)</intensity>
+
+Expected status code to not be 517 received:  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 518 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>518</color><dim>)</intensity>
+
+Expected status code to not be 518 received:  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 519 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>519</color><dim>)</intensity>
+
+Expected status code to not be 519 received:  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 520 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>520</color><dim>)</intensity>
+
+Expected status code to not be 520 received:  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 521 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>521</color><dim>)</intensity>
+
+Expected status code to not be 521 received:  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 522 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>522</color><dim>)</intensity>
+
+Expected status code to not be 522 received:  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 523 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>523</color><dim>)</intensity>
+
+Expected status code to not be 523 received:  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 524 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>524</color><dim>)</intensity>
+
+Expected status code to not be 524 received:  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 525 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>525</color><dim>)</intensity>
+
+Expected status code to not be 525 received:  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 526 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>526</color><dim>)</intensity>
+
+Expected status code to not be 526 received:  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 527 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>527</color><dim>)</intensity>
+
+Expected status code to not be 527 received:  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 528 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>528</color><dim>)</intensity>
+
+Expected status code to not be 528 received:  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 529 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>529</color><dim>)</intensity>
+
+Expected status code to not be 529 received:  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 530 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>530</color><dim>)</intensity>
+
+Expected status code to not be 530 received:  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 531 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>531</color><dim>)</intensity>
+
+Expected status code to not be 531 received:  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 532 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>532</color><dim>)</intensity>
+
+Expected status code to not be 532 received:  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 533 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>533</color><dim>)</intensity>
+
+Expected status code to not be 533 received:  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 534 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>534</color><dim>)</intensity>
+
+Expected status code to not be 534 received:  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 535 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>535</color><dim>)</intensity>
+
+Expected status code to not be 535 received:  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 536 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>536</color><dim>)</intensity>
+
+Expected status code to not be 536 received:  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 537 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>537</color><dim>)</intensity>
+
+Expected status code to not be 537 received:  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 538 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>538</color><dim>)</intensity>
+
+Expected status code to not be 538 received:  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 539 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>539</color><dim>)</intensity>
+
+Expected status code to not be 539 received:  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 540 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>540</color><dim>)</intensity>
+
+Expected status code to not be 540 received:  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 541 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>541</color><dim>)</intensity>
+
+Expected status code to not be 541 received:  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 542 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>542</color><dim>)</intensity>
+
+Expected status code to not be 542 received:  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 543 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>543</color><dim>)</intensity>
+
+Expected status code to not be 543 received:  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 544 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>544</color><dim>)</intensity>
+
+Expected status code to not be 544 received:  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 545 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>545</color><dim>)</intensity>
+
+Expected status code to not be 545 received:  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 546 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>546</color><dim>)</intensity>
+
+Expected status code to not be 546 received:  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 547 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>547</color><dim>)</intensity>
+
+Expected status code to not be 547 received:  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 548 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>548</color><dim>)</intensity>
+
+Expected status code to not be 548 received:  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 549 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>549</color><dim>)</intensity>
+
+Expected status code to not be 549 received:  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 550 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>550</color><dim>)</intensity>
+
+Expected status code to not be 550 received:  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 551 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>551</color><dim>)</intensity>
+
+Expected status code to not be 551 received:  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 552 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>552</color><dim>)</intensity>
+
+Expected status code to not be 552 received:  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 553 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>553</color><dim>)</intensity>
+
+Expected status code to not be 553 received:  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 554 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>554</color><dim>)</intensity>
+
+Expected status code to not be 554 received:  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 555 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>555</color><dim>)</intensity>
+
+Expected status code to not be 555 received:  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 556 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>556</color><dim>)</intensity>
+
+Expected status code to not be 556 received:  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 557 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>557</color><dim>)</intensity>
+
+Expected status code to not be 557 received:  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 558 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>558</color><dim>)</intensity>
+
+Expected status code to not be 558 received:  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 559 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>559</color><dim>)</intensity>
+
+Expected status code to not be 559 received:  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 560 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>560</color><dim>)</intensity>
+
+Expected status code to not be 560 received:  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 561 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>561</color><dim>)</intensity>
+
+Expected status code to not be 561 received:  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 562 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>562</color><dim>)</intensity>
+
+Expected status code to not be 562 received:  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 563 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>563</color><dim>)</intensity>
+
+Expected status code to not be 563 received:  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 564 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>564</color><dim>)</intensity>
+
+Expected status code to not be 564 received:  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 565 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>565</color><dim>)</intensity>
+
+Expected status code to not be 565 received:  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 566 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>566</color><dim>)</intensity>
+
+Expected status code to not be 566 received:  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 567 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>567</color><dim>)</intensity>
+
+Expected status code to not be 567 received:  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 568 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>568</color><dim>)</intensity>
+
+Expected status code to not be 568 received:  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 569 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>569</color><dim>)</intensity>
+
+Expected status code to not be 569 received:  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 570 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>570</color><dim>)</intensity>
+
+Expected status code to not be 570 received:  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 571 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>571</color><dim>)</intensity>
+
+Expected status code to not be 571 received:  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 572 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>572</color><dim>)</intensity>
+
+Expected status code to not be 572 received:  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 573 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>573</color><dim>)</intensity>
+
+Expected status code to not be 573 received:  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 574 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>574</color><dim>)</intensity>
+
+Expected status code to not be 574 received:  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 575 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>575</color><dim>)</intensity>
+
+Expected status code to not be 575 received:  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 576 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>576</color><dim>)</intensity>
+
+Expected status code to not be 576 received:  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 577 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>577</color><dim>)</intensity>
+
+Expected status code to not be 577 received:  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 578 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>578</color><dim>)</intensity>
+
+Expected status code to not be 578 received:  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 579 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>579</color><dim>)</intensity>
+
+Expected status code to not be 579 received:  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 580 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>580</color><dim>)</intensity>
+
+Expected status code to not be 580 received:  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 581 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>581</color><dim>)</intensity>
+
+Expected status code to not be 581 received:  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 582 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>582</color><dim>)</intensity>
+
+Expected status code to not be 582 received:  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 583 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>583</color><dim>)</intensity>
+
+Expected status code to not be 583 received:  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 584 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>584</color><dim>)</intensity>
+
+Expected status code to not be 584 received:  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 585 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>585</color><dim>)</intensity>
+
+Expected status code to not be 585 received:  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 586 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>586</color><dim>)</intensity>
+
+Expected status code to not be 586 received:  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 587 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>587</color><dim>)</intensity>
+
+Expected status code to not be 587 received:  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 588 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>588</color><dim>)</intensity>
+
+Expected status code to not be 588 received:  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 589 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>589</color><dim>)</intensity>
+
+Expected status code to not be 589 received:  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 590 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>590</color><dim>)</intensity>
+
+Expected status code to not be 590 received:  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 591 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>591</color><dim>)</intensity>
+
+Expected status code to not be 591 received:  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 592 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>592</color><dim>)</intensity>
+
+Expected status code to not be 592 received:  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 593 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>593</color><dim>)</intensity>
+
+Expected status code to not be 593 received:  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 594 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>594</color><dim>)</intensity>
+
+Expected status code to not be 594 received:  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 595 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>595</color><dim>)</intensity>
+
+Expected status code to not be 595 received:  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 596 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>596</color><dim>)</intensity>
+
+Expected status code to not be 596 received:  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 597 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>597</color><dim>)</intensity>
+
+Expected status code to not be 597 received:  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 598 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>598</color><dim>)</intensity>
+
+Expected status code to not be 598 received:  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .not.toHaveStatus > status 200 to 599 > fails when response have status code 599 and the actual response status are the same 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveStatus(</intensity><green>599</color><dim>)</intensity>
+
+Expected status code to not be 599 received:  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > fails when given incorrect asymmetric matcher as status 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>Any<String></color><dim>)</intensity>
+
+Expected status code to be Any<String> received:  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>199</color><dim>)</intensity>
+
+Expected status code to be 199 received:  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>200</color><dim>)</intensity>
+
+Expected status code to be 200 received:  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>201</color><dim>)</intensity>
+
+Expected status code to be 201 received:  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>202</color><dim>)</intensity>
+
+Expected status code to be 202 received:  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>203</color><dim>)</intensity>
+
+Expected status code to be 203 received:  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>204</color><dim>)</intensity>
+
+Expected status code to be 204 received:  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>205</color><dim>)</intensity>
+
+Expected status code to be 205 received:  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>206</color><dim>)</intensity>
+
+Expected status code to be 206 received:  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 208 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>207</color><dim>)</intensity>
+
+Expected status code to be 207 received:  <red>208</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 208,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 209 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>208</color><dim>)</intensity>
+
+Expected status code to be 208 received:  <red>209</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 209,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 210 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>209</color><dim>)</intensity>
+
+Expected status code to be 209 received:  <red>210</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 210,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 211 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>210</color><dim>)</intensity>
+
+Expected status code to be 210 received:  <red>211</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 211,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 212 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>211</color><dim>)</intensity>
+
+Expected status code to be 211 received:  <red>212</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 212,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 213 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>212</color><dim>)</intensity>
+
+Expected status code to be 212 received:  <red>213</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 213,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 214 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>213</color><dim>)</intensity>
+
+Expected status code to be 213 received:  <red>214</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 214,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 215 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>214</color><dim>)</intensity>
+
+Expected status code to be 214 received:  <red>215</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 215,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 216 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>215</color><dim>)</intensity>
+
+Expected status code to be 215 received:  <red>216</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 216,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 217 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>216</color><dim>)</intensity>
+
+Expected status code to be 216 received:  <red>217</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 217,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 218 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>217</color><dim>)</intensity>
+
+Expected status code to be 217 received:  <red>218</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 218,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 219 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>218</color><dim>)</intensity>
+
+Expected status code to be 218 received:  <red>219</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 219,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 220 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>219</color><dim>)</intensity>
+
+Expected status code to be 219 received:  <red>220</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 220,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 221 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>220</color><dim>)</intensity>
+
+Expected status code to be 220 received:  <red>221</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 221,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 222 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>221</color><dim>)</intensity>
+
+Expected status code to be 221 received:  <red>222</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 222,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 223 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>222</color><dim>)</intensity>
+
+Expected status code to be 222 received:  <red>223</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 223,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 224 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>223</color><dim>)</intensity>
+
+Expected status code to be 223 received:  <red>224</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 224,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 225 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>224</color><dim>)</intensity>
+
+Expected status code to be 224 received:  <red>225</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 225,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 226 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>225</color><dim>)</intensity>
+
+Expected status code to be 225 received:  <red>226</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 226,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 227 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>226</color><dim>)</intensity>
+
+Expected status code to be 226 received:  <red>227</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 227,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 228 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>227</color><dim>)</intensity>
+
+Expected status code to be 227 received:  <red>228</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 228,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 229 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>228</color><dim>)</intensity>
+
+Expected status code to be 228 received:  <red>229</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 229,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 230 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>229</color><dim>)</intensity>
+
+Expected status code to be 229 received:  <red>230</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 230,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 231 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>230</color><dim>)</intensity>
+
+Expected status code to be 230 received:  <red>231</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 231,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 232 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>231</color><dim>)</intensity>
+
+Expected status code to be 231 received:  <red>232</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 232,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 233 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>232</color><dim>)</intensity>
+
+Expected status code to be 232 received:  <red>233</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 233,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 234 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>233</color><dim>)</intensity>
+
+Expected status code to be 233 received:  <red>234</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 234,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 235 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>234</color><dim>)</intensity>
+
+Expected status code to be 234 received:  <red>235</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 235,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 236 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>235</color><dim>)</intensity>
+
+Expected status code to be 235 received:  <red>236</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 236,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 237 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>236</color><dim>)</intensity>
+
+Expected status code to be 236 received:  <red>237</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 237,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 238 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>237</color><dim>)</intensity>
+
+Expected status code to be 237 received:  <red>238</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 238,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 239 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>238</color><dim>)</intensity>
+
+Expected status code to be 238 received:  <red>239</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 239,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 240 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>239</color><dim>)</intensity>
+
+Expected status code to be 239 received:  <red>240</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 240,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 241 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>240</color><dim>)</intensity>
+
+Expected status code to be 240 received:  <red>241</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 241,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 242 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>241</color><dim>)</intensity>
+
+Expected status code to be 241 received:  <red>242</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 242,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 243 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>242</color><dim>)</intensity>
+
+Expected status code to be 242 received:  <red>243</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 243,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 244 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>243</color><dim>)</intensity>
+
+Expected status code to be 243 received:  <red>244</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 244,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 245 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>244</color><dim>)</intensity>
+
+Expected status code to be 244 received:  <red>245</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 245,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 246 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>245</color><dim>)</intensity>
+
+Expected status code to be 245 received:  <red>246</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 246,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 247 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>246</color><dim>)</intensity>
+
+Expected status code to be 246 received:  <red>247</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 247,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 248 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>247</color><dim>)</intensity>
+
+Expected status code to be 247 received:  <red>248</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 248,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 249 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>248</color><dim>)</intensity>
+
+Expected status code to be 248 received:  <red>249</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 249,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 250 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>249</color><dim>)</intensity>
+
+Expected status code to be 249 received:  <red>250</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 250,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 251 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>250</color><dim>)</intensity>
+
+Expected status code to be 250 received:  <red>251</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 251,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 252 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>251</color><dim>)</intensity>
+
+Expected status code to be 251 received:  <red>252</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 252,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 253 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>252</color><dim>)</intensity>
+
+Expected status code to be 252 received:  <red>253</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 253,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 254 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>253</color><dim>)</intensity>
+
+Expected status code to be 253 received:  <red>254</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 254,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 255 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>254</color><dim>)</intensity>
+
+Expected status code to be 254 received:  <red>255</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 255,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 256 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>255</color><dim>)</intensity>
+
+Expected status code to be 255 received:  <red>256</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 256,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 257 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>256</color><dim>)</intensity>
+
+Expected status code to be 256 received:  <red>257</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 257,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 258 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>257</color><dim>)</intensity>
+
+Expected status code to be 257 received:  <red>258</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 258,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 259 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>258</color><dim>)</intensity>
+
+Expected status code to be 258 received:  <red>259</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 259,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 260 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>259</color><dim>)</intensity>
+
+Expected status code to be 259 received:  <red>260</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 260,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 261 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>260</color><dim>)</intensity>
+
+Expected status code to be 260 received:  <red>261</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 261,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 262 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>261</color><dim>)</intensity>
+
+Expected status code to be 261 received:  <red>262</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 262,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 263 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>262</color><dim>)</intensity>
+
+Expected status code to be 262 received:  <red>263</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 263,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 264 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>263</color><dim>)</intensity>
+
+Expected status code to be 263 received:  <red>264</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 264,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 265 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>264</color><dim>)</intensity>
+
+Expected status code to be 264 received:  <red>265</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 265,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 266 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>265</color><dim>)</intensity>
+
+Expected status code to be 265 received:  <red>266</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 266,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 267 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>266</color><dim>)</intensity>
+
+Expected status code to be 266 received:  <red>267</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 267,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 268 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>267</color><dim>)</intensity>
+
+Expected status code to be 267 received:  <red>268</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 268,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 269 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>268</color><dim>)</intensity>
+
+Expected status code to be 268 received:  <red>269</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 269,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 270 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>269</color><dim>)</intensity>
+
+Expected status code to be 269 received:  <red>270</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 270,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 271 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>270</color><dim>)</intensity>
+
+Expected status code to be 270 received:  <red>271</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 271,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 272 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>271</color><dim>)</intensity>
+
+Expected status code to be 271 received:  <red>272</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 272,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 273 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>272</color><dim>)</intensity>
+
+Expected status code to be 272 received:  <red>273</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 273,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 274 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>273</color><dim>)</intensity>
+
+Expected status code to be 273 received:  <red>274</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 274,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 275 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>274</color><dim>)</intensity>
+
+Expected status code to be 274 received:  <red>275</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 275,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 276 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>275</color><dim>)</intensity>
+
+Expected status code to be 275 received:  <red>276</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 276,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 277 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>276</color><dim>)</intensity>
+
+Expected status code to be 276 received:  <red>277</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 277,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 278 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>277</color><dim>)</intensity>
+
+Expected status code to be 277 received:  <red>278</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 278,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 279 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>278</color><dim>)</intensity>
+
+Expected status code to be 278 received:  <red>279</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 279,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 280 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>279</color><dim>)</intensity>
+
+Expected status code to be 279 received:  <red>280</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 280,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 281 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>280</color><dim>)</intensity>
+
+Expected status code to be 280 received:  <red>281</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 281,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 282 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>281</color><dim>)</intensity>
+
+Expected status code to be 281 received:  <red>282</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 282,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 283 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>282</color><dim>)</intensity>
+
+Expected status code to be 282 received:  <red>283</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 283,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 284 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>283</color><dim>)</intensity>
+
+Expected status code to be 283 received:  <red>284</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 284,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 285 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>284</color><dim>)</intensity>
+
+Expected status code to be 284 received:  <red>285</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 285,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 286 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>285</color><dim>)</intensity>
+
+Expected status code to be 285 received:  <red>286</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 286,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 287 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>286</color><dim>)</intensity>
+
+Expected status code to be 286 received:  <red>287</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 287,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 288 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>287</color><dim>)</intensity>
+
+Expected status code to be 287 received:  <red>288</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 288,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 289 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>288</color><dim>)</intensity>
+
+Expected status code to be 288 received:  <red>289</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 289,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 290 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>289</color><dim>)</intensity>
+
+Expected status code to be 289 received:  <red>290</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 290,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 291 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>290</color><dim>)</intensity>
+
+Expected status code to be 290 received:  <red>291</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 291,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 292 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>291</color><dim>)</intensity>
+
+Expected status code to be 291 received:  <red>292</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 292,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 293 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>292</color><dim>)</intensity>
+
+Expected status code to be 292 received:  <red>293</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 293,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 294 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>293</color><dim>)</intensity>
+
+Expected status code to be 293 received:  <red>294</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 294,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 295 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>294</color><dim>)</intensity>
+
+Expected status code to be 294 received:  <red>295</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 295,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 296 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>295</color><dim>)</intensity>
+
+Expected status code to be 295 received:  <red>296</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 296,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 297 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>296</color><dim>)</intensity>
+
+Expected status code to be 296 received:  <red>297</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 297,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 298 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>297</color><dim>)</intensity>
+
+Expected status code to be 297 received:  <red>298</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 298,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 299 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>298</color><dim>)</intensity>
+
+Expected status code to be 298 received:  <red>299</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 299,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>299</color><dim>)</intensity>
+
+Expected status code to be 299 received:  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>300</color><dim>)</intensity>
+
+Expected status code to be 300 received:  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>301</color><dim>)</intensity>
+
+Expected status code to be 301 received:  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>302</color><dim>)</intensity>
+
+Expected status code to be 302 received:  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>303</color><dim>)</intensity>
+
+Expected status code to be 303 received:  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>304</color><dim>)</intensity>
+
+Expected status code to be 304 received:  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 306 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>305</color><dim>)</intensity>
+
+Expected status code to be 305 received:  <red>306</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 306,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>306</color><dim>)</intensity>
+
+Expected status code to be 306 received:  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>307</color><dim>)</intensity>
+
+Expected status code to be 307 received:  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 309 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>308</color><dim>)</intensity>
+
+Expected status code to be 308 received:  <red>309</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 309,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 310 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>309</color><dim>)</intensity>
+
+Expected status code to be 309 received:  <red>310</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 310,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 311 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>310</color><dim>)</intensity>
+
+Expected status code to be 310 received:  <red>311</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 311,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 312 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>311</color><dim>)</intensity>
+
+Expected status code to be 311 received:  <red>312</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 312,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 313 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>312</color><dim>)</intensity>
+
+Expected status code to be 312 received:  <red>313</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 313,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 314 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>313</color><dim>)</intensity>
+
+Expected status code to be 313 received:  <red>314</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 314,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 315 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>314</color><dim>)</intensity>
+
+Expected status code to be 314 received:  <red>315</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 315,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 316 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>315</color><dim>)</intensity>
+
+Expected status code to be 315 received:  <red>316</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 316,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 317 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>316</color><dim>)</intensity>
+
+Expected status code to be 316 received:  <red>317</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 317,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 318 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>317</color><dim>)</intensity>
+
+Expected status code to be 317 received:  <red>318</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 318,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 319 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>318</color><dim>)</intensity>
+
+Expected status code to be 318 received:  <red>319</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 319,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 320 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>319</color><dim>)</intensity>
+
+Expected status code to be 319 received:  <red>320</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 320,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 321 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>320</color><dim>)</intensity>
+
+Expected status code to be 320 received:  <red>321</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 321,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 322 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>321</color><dim>)</intensity>
+
+Expected status code to be 321 received:  <red>322</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 322,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 323 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>322</color><dim>)</intensity>
+
+Expected status code to be 322 received:  <red>323</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 323,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 324 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>323</color><dim>)</intensity>
+
+Expected status code to be 323 received:  <red>324</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 324,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 325 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>324</color><dim>)</intensity>
+
+Expected status code to be 324 received:  <red>325</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 325,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 326 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>325</color><dim>)</intensity>
+
+Expected status code to be 325 received:  <red>326</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 326,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 327 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>326</color><dim>)</intensity>
+
+Expected status code to be 326 received:  <red>327</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 327,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 328 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>327</color><dim>)</intensity>
+
+Expected status code to be 327 received:  <red>328</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 328,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 329 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>328</color><dim>)</intensity>
+
+Expected status code to be 328 received:  <red>329</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 329,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 330 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>329</color><dim>)</intensity>
+
+Expected status code to be 329 received:  <red>330</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 330,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 331 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>330</color><dim>)</intensity>
+
+Expected status code to be 330 received:  <red>331</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 331,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 332 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>331</color><dim>)</intensity>
+
+Expected status code to be 331 received:  <red>332</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 332,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 333 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>332</color><dim>)</intensity>
+
+Expected status code to be 332 received:  <red>333</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 333,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 334 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>333</color><dim>)</intensity>
+
+Expected status code to be 333 received:  <red>334</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 334,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 335 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>334</color><dim>)</intensity>
+
+Expected status code to be 334 received:  <red>335</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 335,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 336 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>335</color><dim>)</intensity>
+
+Expected status code to be 335 received:  <red>336</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 336,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 337 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>336</color><dim>)</intensity>
+
+Expected status code to be 336 received:  <red>337</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 337,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 338 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>337</color><dim>)</intensity>
+
+Expected status code to be 337 received:  <red>338</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 338,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 339 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>338</color><dim>)</intensity>
+
+Expected status code to be 338 received:  <red>339</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 339,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 340 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>339</color><dim>)</intensity>
+
+Expected status code to be 339 received:  <red>340</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 340,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 341 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>340</color><dim>)</intensity>
+
+Expected status code to be 340 received:  <red>341</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 341,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 342 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>341</color><dim>)</intensity>
+
+Expected status code to be 341 received:  <red>342</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 342,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 343 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>342</color><dim>)</intensity>
+
+Expected status code to be 342 received:  <red>343</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 343,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 344 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>343</color><dim>)</intensity>
+
+Expected status code to be 343 received:  <red>344</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 344,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 345 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>344</color><dim>)</intensity>
+
+Expected status code to be 344 received:  <red>345</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 345,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 346 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>345</color><dim>)</intensity>
+
+Expected status code to be 345 received:  <red>346</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 346,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 347 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>346</color><dim>)</intensity>
+
+Expected status code to be 346 received:  <red>347</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 347,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 348 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>347</color><dim>)</intensity>
+
+Expected status code to be 347 received:  <red>348</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 348,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 349 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>348</color><dim>)</intensity>
+
+Expected status code to be 348 received:  <red>349</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 349,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 350 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>349</color><dim>)</intensity>
+
+Expected status code to be 349 received:  <red>350</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 350,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 351 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>350</color><dim>)</intensity>
+
+Expected status code to be 350 received:  <red>351</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 351,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 352 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>351</color><dim>)</intensity>
+
+Expected status code to be 351 received:  <red>352</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 352,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 353 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>352</color><dim>)</intensity>
+
+Expected status code to be 352 received:  <red>353</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 353,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 354 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>353</color><dim>)</intensity>
+
+Expected status code to be 353 received:  <red>354</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 354,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 355 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>354</color><dim>)</intensity>
+
+Expected status code to be 354 received:  <red>355</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 355,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 356 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>355</color><dim>)</intensity>
+
+Expected status code to be 355 received:  <red>356</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 356,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 357 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>356</color><dim>)</intensity>
+
+Expected status code to be 356 received:  <red>357</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 357,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 358 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>357</color><dim>)</intensity>
+
+Expected status code to be 357 received:  <red>358</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 358,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 359 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>358</color><dim>)</intensity>
+
+Expected status code to be 358 received:  <red>359</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 359,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 360 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>359</color><dim>)</intensity>
+
+Expected status code to be 359 received:  <red>360</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 360,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 361 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>360</color><dim>)</intensity>
+
+Expected status code to be 360 received:  <red>361</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 361,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 362 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>361</color><dim>)</intensity>
+
+Expected status code to be 361 received:  <red>362</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 362,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 363 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>362</color><dim>)</intensity>
+
+Expected status code to be 362 received:  <red>363</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 363,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 364 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>363</color><dim>)</intensity>
+
+Expected status code to be 363 received:  <red>364</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 364,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 365 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>364</color><dim>)</intensity>
+
+Expected status code to be 364 received:  <red>365</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 365,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 366 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>365</color><dim>)</intensity>
+
+Expected status code to be 365 received:  <red>366</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 366,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 367 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>366</color><dim>)</intensity>
+
+Expected status code to be 366 received:  <red>367</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 367,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 368 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>367</color><dim>)</intensity>
+
+Expected status code to be 367 received:  <red>368</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 368,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 369 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>368</color><dim>)</intensity>
+
+Expected status code to be 368 received:  <red>369</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 369,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 370 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>369</color><dim>)</intensity>
+
+Expected status code to be 369 received:  <red>370</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 370,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 371 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>370</color><dim>)</intensity>
+
+Expected status code to be 370 received:  <red>371</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 371,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 372 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>371</color><dim>)</intensity>
+
+Expected status code to be 371 received:  <red>372</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 372,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 373 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>372</color><dim>)</intensity>
+
+Expected status code to be 372 received:  <red>373</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 373,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 374 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>373</color><dim>)</intensity>
+
+Expected status code to be 373 received:  <red>374</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 374,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 375 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>374</color><dim>)</intensity>
+
+Expected status code to be 374 received:  <red>375</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 375,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 376 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>375</color><dim>)</intensity>
+
+Expected status code to be 375 received:  <red>376</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 376,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 377 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>376</color><dim>)</intensity>
+
+Expected status code to be 376 received:  <red>377</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 377,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 378 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>377</color><dim>)</intensity>
+
+Expected status code to be 377 received:  <red>378</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 378,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 379 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>378</color><dim>)</intensity>
+
+Expected status code to be 378 received:  <red>379</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 379,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 380 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>379</color><dim>)</intensity>
+
+Expected status code to be 379 received:  <red>380</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 380,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 381 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>380</color><dim>)</intensity>
+
+Expected status code to be 380 received:  <red>381</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 381,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 382 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>381</color><dim>)</intensity>
+
+Expected status code to be 381 received:  <red>382</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 382,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 383 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>382</color><dim>)</intensity>
+
+Expected status code to be 382 received:  <red>383</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 383,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 384 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>383</color><dim>)</intensity>
+
+Expected status code to be 383 received:  <red>384</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 384,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 385 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>384</color><dim>)</intensity>
+
+Expected status code to be 384 received:  <red>385</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 385,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 386 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>385</color><dim>)</intensity>
+
+Expected status code to be 385 received:  <red>386</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 386,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 387 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>386</color><dim>)</intensity>
+
+Expected status code to be 386 received:  <red>387</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 387,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 388 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>387</color><dim>)</intensity>
+
+Expected status code to be 387 received:  <red>388</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 388,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 389 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>388</color><dim>)</intensity>
+
+Expected status code to be 388 received:  <red>389</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 389,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 390 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>389</color><dim>)</intensity>
+
+Expected status code to be 389 received:  <red>390</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 390,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 391 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>390</color><dim>)</intensity>
+
+Expected status code to be 390 received:  <red>391</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 391,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 392 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>391</color><dim>)</intensity>
+
+Expected status code to be 391 received:  <red>392</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 392,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 393 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>392</color><dim>)</intensity>
+
+Expected status code to be 392 received:  <red>393</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 393,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 394 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>393</color><dim>)</intensity>
+
+Expected status code to be 393 received:  <red>394</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 394,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 395 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>394</color><dim>)</intensity>
+
+Expected status code to be 394 received:  <red>395</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 395,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 396 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>395</color><dim>)</intensity>
+
+Expected status code to be 395 received:  <red>396</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 396,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 397 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>396</color><dim>)</intensity>
+
+Expected status code to be 396 received:  <red>397</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 397,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 398 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>397</color><dim>)</intensity>
+
+Expected status code to be 397 received:  <red>398</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 398,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 399 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>398</color><dim>)</intensity>
+
+Expected status code to be 398 received:  <red>399</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 399,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>399</color><dim>)</intensity>
+
+Expected status code to be 399 received:  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>400</color><dim>)</intensity>
+
+Expected status code to be 400 received:  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>401</color><dim>)</intensity>
+
+Expected status code to be 401 received:  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>402</color><dim>)</intensity>
+
+Expected status code to be 402 received:  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>403</color><dim>)</intensity>
+
+Expected status code to be 403 received:  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>404</color><dim>)</intensity>
+
+Expected status code to be 404 received:  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>405</color><dim>)</intensity>
+
+Expected status code to be 405 received:  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>406</color><dim>)</intensity>
+
+Expected status code to be 406 received:  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>407</color><dim>)</intensity>
+
+Expected status code to be 407 received:  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>408</color><dim>)</intensity>
+
+Expected status code to be 408 received:  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>409</color><dim>)</intensity>
+
+Expected status code to be 409 received:  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>410</color><dim>)</intensity>
+
+Expected status code to be 410 received:  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>411</color><dim>)</intensity>
+
+Expected status code to be 411 received:  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>412</color><dim>)</intensity>
+
+Expected status code to be 412 received:  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>413</color><dim>)</intensity>
+
+Expected status code to be 413 received:  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>414</color><dim>)</intensity>
+
+Expected status code to be 414 received:  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>415</color><dim>)</intensity>
+
+Expected status code to be 415 received:  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>416</color><dim>)</intensity>
+
+Expected status code to be 416 received:  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>417</color><dim>)</intensity>
+
+Expected status code to be 417 received:  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>418</color><dim>)</intensity>
+
+Expected status code to be 418 received:  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>419</color><dim>)</intensity>
+
+Expected status code to be 419 received:  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>420</color><dim>)</intensity>
+
+Expected status code to be 420 received:  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>421</color><dim>)</intensity>
+
+Expected status code to be 421 received:  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>422</color><dim>)</intensity>
+
+Expected status code to be 422 received:  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>423</color><dim>)</intensity>
+
+Expected status code to be 423 received:  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 425 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>424</color><dim>)</intensity>
+
+Expected status code to be 424 received:  <red>425</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 425,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>425</color><dim>)</intensity>
+
+Expected status code to be 425 received:  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 427 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>426</color><dim>)</intensity>
+
+Expected status code to be 426 received:  <red>427</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 427,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>427</color><dim>)</intensity>
+
+Expected status code to be 427 received:  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>428</color><dim>)</intensity>
+
+Expected status code to be 428 received:  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 430 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>429</color><dim>)</intensity>
+
+Expected status code to be 429 received:  <red>430</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 430,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>430</color><dim>)</intensity>
+
+Expected status code to be 430 received:  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 432 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>431</color><dim>)</intensity>
+
+Expected status code to be 431 received:  <red>432</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 432,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 433 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>432</color><dim>)</intensity>
+
+Expected status code to be 432 received:  <red>433</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 433,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 434 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>433</color><dim>)</intensity>
+
+Expected status code to be 433 received:  <red>434</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 434,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 435 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>434</color><dim>)</intensity>
+
+Expected status code to be 434 received:  <red>435</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 435,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 436 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>435</color><dim>)</intensity>
+
+Expected status code to be 435 received:  <red>436</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 436,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 437 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>436</color><dim>)</intensity>
+
+Expected status code to be 436 received:  <red>437</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 437,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 438 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>437</color><dim>)</intensity>
+
+Expected status code to be 437 received:  <red>438</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 438,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 439 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>438</color><dim>)</intensity>
+
+Expected status code to be 438 received:  <red>439</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 439,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 440 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>439</color><dim>)</intensity>
+
+Expected status code to be 439 received:  <red>440</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 440,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 441 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>440</color><dim>)</intensity>
+
+Expected status code to be 440 received:  <red>441</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 441,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 442 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>441</color><dim>)</intensity>
+
+Expected status code to be 441 received:  <red>442</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 442,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 443 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>442</color><dim>)</intensity>
+
+Expected status code to be 442 received:  <red>443</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 443,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 444 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>443</color><dim>)</intensity>
+
+Expected status code to be 443 received:  <red>444</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 444,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 445 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>444</color><dim>)</intensity>
+
+Expected status code to be 444 received:  <red>445</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 445,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 446 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>445</color><dim>)</intensity>
+
+Expected status code to be 445 received:  <red>446</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 446,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 447 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>446</color><dim>)</intensity>
+
+Expected status code to be 446 received:  <red>447</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 447,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 448 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>447</color><dim>)</intensity>
+
+Expected status code to be 447 received:  <red>448</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 448,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 449 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>448</color><dim>)</intensity>
+
+Expected status code to be 448 received:  <red>449</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 449,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 450 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>449</color><dim>)</intensity>
+
+Expected status code to be 449 received:  <red>450</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 450,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>450</color><dim>)</intensity>
+
+Expected status code to be 450 received:  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 452 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>451</color><dim>)</intensity>
+
+Expected status code to be 451 received:  <red>452</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 452,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 453 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>452</color><dim>)</intensity>
+
+Expected status code to be 452 received:  <red>453</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 453,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 454 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>453</color><dim>)</intensity>
+
+Expected status code to be 453 received:  <red>454</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 454,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 455 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>454</color><dim>)</intensity>
+
+Expected status code to be 454 received:  <red>455</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 455,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 456 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>455</color><dim>)</intensity>
+
+Expected status code to be 455 received:  <red>456</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 456,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 457 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>456</color><dim>)</intensity>
+
+Expected status code to be 456 received:  <red>457</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 457,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 458 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>457</color><dim>)</intensity>
+
+Expected status code to be 457 received:  <red>458</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 458,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 459 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>458</color><dim>)</intensity>
+
+Expected status code to be 458 received:  <red>459</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 459,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 460 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>459</color><dim>)</intensity>
+
+Expected status code to be 459 received:  <red>460</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 460,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 461 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>460</color><dim>)</intensity>
+
+Expected status code to be 460 received:  <red>461</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 461,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 462 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>461</color><dim>)</intensity>
+
+Expected status code to be 461 received:  <red>462</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 462,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 463 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>462</color><dim>)</intensity>
+
+Expected status code to be 462 received:  <red>463</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 463,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 464 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>463</color><dim>)</intensity>
+
+Expected status code to be 463 received:  <red>464</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 464,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 465 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>464</color><dim>)</intensity>
+
+Expected status code to be 464 received:  <red>465</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 465,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 466 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>465</color><dim>)</intensity>
+
+Expected status code to be 465 received:  <red>466</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 466,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 467 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>466</color><dim>)</intensity>
+
+Expected status code to be 466 received:  <red>467</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 467,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 468 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>467</color><dim>)</intensity>
+
+Expected status code to be 467 received:  <red>468</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 468,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 469 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>468</color><dim>)</intensity>
+
+Expected status code to be 468 received:  <red>469</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 469,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 470 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>469</color><dim>)</intensity>
+
+Expected status code to be 469 received:  <red>470</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 470,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 471 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>470</color><dim>)</intensity>
+
+Expected status code to be 470 received:  <red>471</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 471,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 472 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>471</color><dim>)</intensity>
+
+Expected status code to be 471 received:  <red>472</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 472,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 473 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>472</color><dim>)</intensity>
+
+Expected status code to be 472 received:  <red>473</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 473,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 474 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>473</color><dim>)</intensity>
+
+Expected status code to be 473 received:  <red>474</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 474,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 475 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>474</color><dim>)</intensity>
+
+Expected status code to be 474 received:  <red>475</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 475,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 476 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>475</color><dim>)</intensity>
+
+Expected status code to be 475 received:  <red>476</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 476,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 477 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>476</color><dim>)</intensity>
+
+Expected status code to be 476 received:  <red>477</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 477,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 478 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>477</color><dim>)</intensity>
+
+Expected status code to be 477 received:  <red>478</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 478,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 479 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>478</color><dim>)</intensity>
+
+Expected status code to be 478 received:  <red>479</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 479,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 480 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>479</color><dim>)</intensity>
+
+Expected status code to be 479 received:  <red>480</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 480,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 481 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>480</color><dim>)</intensity>
+
+Expected status code to be 480 received:  <red>481</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 481,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 482 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>481</color><dim>)</intensity>
+
+Expected status code to be 481 received:  <red>482</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 482,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 483 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>482</color><dim>)</intensity>
+
+Expected status code to be 482 received:  <red>483</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 483,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 484 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>483</color><dim>)</intensity>
+
+Expected status code to be 483 received:  <red>484</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 484,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 485 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>484</color><dim>)</intensity>
+
+Expected status code to be 484 received:  <red>485</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 485,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 486 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>485</color><dim>)</intensity>
+
+Expected status code to be 485 received:  <red>486</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 486,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 487 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>486</color><dim>)</intensity>
+
+Expected status code to be 486 received:  <red>487</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 487,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 488 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>487</color><dim>)</intensity>
+
+Expected status code to be 487 received:  <red>488</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 488,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 489 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>488</color><dim>)</intensity>
+
+Expected status code to be 488 received:  <red>489</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 489,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 490 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>489</color><dim>)</intensity>
+
+Expected status code to be 489 received:  <red>490</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 490,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 491 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>490</color><dim>)</intensity>
+
+Expected status code to be 490 received:  <red>491</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 491,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 492 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>491</color><dim>)</intensity>
+
+Expected status code to be 491 received:  <red>492</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 492,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 493 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>492</color><dim>)</intensity>
+
+Expected status code to be 492 received:  <red>493</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 493,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 494 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>493</color><dim>)</intensity>
+
+Expected status code to be 493 received:  <red>494</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 494,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 495 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>494</color><dim>)</intensity>
+
+Expected status code to be 494 received:  <red>495</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 495,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 496 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>495</color><dim>)</intensity>
+
+Expected status code to be 495 received:  <red>496</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 496,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 497 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>496</color><dim>)</intensity>
+
+Expected status code to be 496 received:  <red>497</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 497,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 498 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>497</color><dim>)</intensity>
+
+Expected status code to be 497 received:  <red>498</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 498,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 499 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>498</color><dim>)</intensity>
+
+Expected status code to be 498 received:  <red>499</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 499,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>499</color><dim>)</intensity>
+
+Expected status code to be 499 received:  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>500</color><dim>)</intensity>
+
+Expected status code to be 500 received:  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>501</color><dim>)</intensity>
+
+Expected status code to be 501 received:  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>502</color><dim>)</intensity>
+
+Expected status code to be 502 received:  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>503</color><dim>)</intensity>
+
+Expected status code to be 503 received:  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>504</color><dim>)</intensity>
+
+Expected status code to be 504 received:  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 506 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>505</color><dim>)</intensity>
+
+Expected status code to be 505 received:  <red>506</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 506,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>506</color><dim>)</intensity>
+
+Expected status code to be 506 received:  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 508 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>507</color><dim>)</intensity>
+
+Expected status code to be 507 received:  <red>508</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 508,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 509 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>508</color><dim>)</intensity>
+
+Expected status code to be 508 received:  <red>509</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 509,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 510 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>509</color><dim>)</intensity>
+
+Expected status code to be 509 received:  <red>510</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 510,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>510</color><dim>)</intensity>
+
+Expected status code to be 510 received:  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 512 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>511</color><dim>)</intensity>
+
+Expected status code to be 511 received:  <red>512</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 512,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 513 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>512</color><dim>)</intensity>
+
+Expected status code to be 512 received:  <red>513</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 513,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 514 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>513</color><dim>)</intensity>
+
+Expected status code to be 513 received:  <red>514</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 514,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 515 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>514</color><dim>)</intensity>
+
+Expected status code to be 514 received:  <red>515</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 515,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 516 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>515</color><dim>)</intensity>
+
+Expected status code to be 515 received:  <red>516</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 516,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 517 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>516</color><dim>)</intensity>
+
+Expected status code to be 516 received:  <red>517</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 517,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 518 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>517</color><dim>)</intensity>
+
+Expected status code to be 517 received:  <red>518</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 518,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 519 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>518</color><dim>)</intensity>
+
+Expected status code to be 518 received:  <red>519</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 519,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 520 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>519</color><dim>)</intensity>
+
+Expected status code to be 519 received:  <red>520</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 520,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 521 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>520</color><dim>)</intensity>
+
+Expected status code to be 520 received:  <red>521</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 521,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 522 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>521</color><dim>)</intensity>
+
+Expected status code to be 521 received:  <red>522</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 522,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 523 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>522</color><dim>)</intensity>
+
+Expected status code to be 522 received:  <red>523</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 523,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 524 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>523</color><dim>)</intensity>
+
+Expected status code to be 523 received:  <red>524</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 524,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 525 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>524</color><dim>)</intensity>
+
+Expected status code to be 524 received:  <red>525</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 525,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 526 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>525</color><dim>)</intensity>
+
+Expected status code to be 525 received:  <red>526</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 526,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 527 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>526</color><dim>)</intensity>
+
+Expected status code to be 526 received:  <red>527</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 527,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 528 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>527</color><dim>)</intensity>
+
+Expected status code to be 527 received:  <red>528</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 528,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 529 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>528</color><dim>)</intensity>
+
+Expected status code to be 528 received:  <red>529</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 529,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 530 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>529</color><dim>)</intensity>
+
+Expected status code to be 529 received:  <red>530</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 530,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 531 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>530</color><dim>)</intensity>
+
+Expected status code to be 530 received:  <red>531</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 531,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 532 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>531</color><dim>)</intensity>
+
+Expected status code to be 531 received:  <red>532</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 532,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 533 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>532</color><dim>)</intensity>
+
+Expected status code to be 532 received:  <red>533</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 533,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 534 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>533</color><dim>)</intensity>
+
+Expected status code to be 533 received:  <red>534</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 534,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 535 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>534</color><dim>)</intensity>
+
+Expected status code to be 534 received:  <red>535</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 535,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 536 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>535</color><dim>)</intensity>
+
+Expected status code to be 535 received:  <red>536</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 536,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 537 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>536</color><dim>)</intensity>
+
+Expected status code to be 536 received:  <red>537</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 537,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 538 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>537</color><dim>)</intensity>
+
+Expected status code to be 537 received:  <red>538</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 538,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 539 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>538</color><dim>)</intensity>
+
+Expected status code to be 538 received:  <red>539</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 539,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 540 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>539</color><dim>)</intensity>
+
+Expected status code to be 539 received:  <red>540</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 540,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 541 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>540</color><dim>)</intensity>
+
+Expected status code to be 540 received:  <red>541</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 541,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 542 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>541</color><dim>)</intensity>
+
+Expected status code to be 541 received:  <red>542</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 542,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 543 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>542</color><dim>)</intensity>
+
+Expected status code to be 542 received:  <red>543</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 543,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 544 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>543</color><dim>)</intensity>
+
+Expected status code to be 543 received:  <red>544</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 544,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 545 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>544</color><dim>)</intensity>
+
+Expected status code to be 544 received:  <red>545</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 545,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 546 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>545</color><dim>)</intensity>
+
+Expected status code to be 545 received:  <red>546</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 546,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 547 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>546</color><dim>)</intensity>
+
+Expected status code to be 546 received:  <red>547</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 547,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 548 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>547</color><dim>)</intensity>
+
+Expected status code to be 547 received:  <red>548</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 548,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 549 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>548</color><dim>)</intensity>
+
+Expected status code to be 548 received:  <red>549</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 549,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 550 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>549</color><dim>)</intensity>
+
+Expected status code to be 549 received:  <red>550</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 550,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 551 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>550</color><dim>)</intensity>
+
+Expected status code to be 550 received:  <red>551</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 551,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 552 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>551</color><dim>)</intensity>
+
+Expected status code to be 551 received:  <red>552</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 552,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 553 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>552</color><dim>)</intensity>
+
+Expected status code to be 552 received:  <red>553</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 553,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 554 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>553</color><dim>)</intensity>
+
+Expected status code to be 553 received:  <red>554</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 554,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 555 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>554</color><dim>)</intensity>
+
+Expected status code to be 554 received:  <red>555</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 555,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 556 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>555</color><dim>)</intensity>
+
+Expected status code to be 555 received:  <red>556</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 556,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 557 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>556</color><dim>)</intensity>
+
+Expected status code to be 556 received:  <red>557</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 557,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 558 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>557</color><dim>)</intensity>
+
+Expected status code to be 557 received:  <red>558</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 558,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 559 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>558</color><dim>)</intensity>
+
+Expected status code to be 558 received:  <red>559</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 559,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 560 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>559</color><dim>)</intensity>
+
+Expected status code to be 559 received:  <red>560</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 560,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 561 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>560</color><dim>)</intensity>
+
+Expected status code to be 560 received:  <red>561</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 561,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 562 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>561</color><dim>)</intensity>
+
+Expected status code to be 561 received:  <red>562</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 562,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 563 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>562</color><dim>)</intensity>
+
+Expected status code to be 562 received:  <red>563</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 563,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 564 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>563</color><dim>)</intensity>
+
+Expected status code to be 563 received:  <red>564</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 564,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 565 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>564</color><dim>)</intensity>
+
+Expected status code to be 564 received:  <red>565</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 565,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 566 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>565</color><dim>)</intensity>
+
+Expected status code to be 565 received:  <red>566</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 566,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 567 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>566</color><dim>)</intensity>
+
+Expected status code to be 566 received:  <red>567</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 567,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 568 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>567</color><dim>)</intensity>
+
+Expected status code to be 567 received:  <red>568</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 568,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 569 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>568</color><dim>)</intensity>
+
+Expected status code to be 568 received:  <red>569</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 569,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 570 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>569</color><dim>)</intensity>
+
+Expected status code to be 569 received:  <red>570</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 570,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 571 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>570</color><dim>)</intensity>
+
+Expected status code to be 570 received:  <red>571</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 571,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 572 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>571</color><dim>)</intensity>
+
+Expected status code to be 571 received:  <red>572</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 572,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 573 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>572</color><dim>)</intensity>
+
+Expected status code to be 572 received:  <red>573</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 573,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 574 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>573</color><dim>)</intensity>
+
+Expected status code to be 573 received:  <red>574</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 574,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 575 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>574</color><dim>)</intensity>
+
+Expected status code to be 574 received:  <red>575</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 575,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 576 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>575</color><dim>)</intensity>
+
+Expected status code to be 575 received:  <red>576</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 576,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 577 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>576</color><dim>)</intensity>
+
+Expected status code to be 576 received:  <red>577</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 577,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 578 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>577</color><dim>)</intensity>
+
+Expected status code to be 577 received:  <red>578</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 578,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 579 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>578</color><dim>)</intensity>
+
+Expected status code to be 578 received:  <red>579</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 579,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 580 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>579</color><dim>)</intensity>
+
+Expected status code to be 579 received:  <red>580</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 580,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 581 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>580</color><dim>)</intensity>
+
+Expected status code to be 580 received:  <red>581</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 581,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 582 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>581</color><dim>)</intensity>
+
+Expected status code to be 581 received:  <red>582</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 582,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 583 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>582</color><dim>)</intensity>
+
+Expected status code to be 582 received:  <red>583</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 583,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 584 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>583</color><dim>)</intensity>
+
+Expected status code to be 583 received:  <red>584</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 584,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 585 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>584</color><dim>)</intensity>
+
+Expected status code to be 584 received:  <red>585</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 585,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 586 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>585</color><dim>)</intensity>
+
+Expected status code to be 585 received:  <red>586</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 586,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 587 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>586</color><dim>)</intensity>
+
+Expected status code to be 586 received:  <red>587</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 587,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 588 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>587</color><dim>)</intensity>
+
+Expected status code to be 587 received:  <red>588</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 588,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 589 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>588</color><dim>)</intensity>
+
+Expected status code to be 588 received:  <red>589</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 589,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 590 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>589</color><dim>)</intensity>
+
+Expected status code to be 589 received:  <red>590</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 590,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 591 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>590</color><dim>)</intensity>
+
+Expected status code to be 590 received:  <red>591</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 591,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 592 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>591</color><dim>)</intensity>
+
+Expected status code to be 591 received:  <red>592</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 592,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 593 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>592</color><dim>)</intensity>
+
+Expected status code to be 592 received:  <red>593</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 593,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 594 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>593</color><dim>)</intensity>
+
+Expected status code to be 593 received:  <red>594</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 594,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 595 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>594</color><dim>)</intensity>
+
+Expected status code to be 594 received:  <red>595</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 595,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 596 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>595</color><dim>)</intensity>
+
+Expected status code to be 595 received:  <red>596</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 596,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 597 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>596</color><dim>)</intensity>
+
+Expected status code to be 596 received:  <red>597</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 597,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 598 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>597</color><dim>)</intensity>
+
+Expected status code to be 597 received:  <red>598</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 598,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveStatus > using got > .toHaveStatus > status 200 to 599 > fails when response have status code 599 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveStatus(</intensity><green>598</color><dim>)</intensity>
+
+Expected status code to be 598 received:  <red>599</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 599,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveAcceptedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveAcceptedStatus.test.js.snapshot
index caaae4c..80a7da0 100644
--- a/test/matchers/status/specific/toHaveAcceptedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveAcceptedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveAcceptedStatus > using got > .not.toHaveAcceptedStatus > fails when response have status code 202 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveAcceptedStatus()</intensity>
+
+Expected status code to not be 202 received:
+  <red>202</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 202,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveAcceptedStatus > using got > .toHaveAcceptedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveAcceptedStatus()</intensity>
+
+Expected status code to be 202 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveBadGatewayStatus.test.js.snapshot b/test/matchers/status/specific/toHaveBadGatewayStatus.test.js.snapshot
index 9d43cab..f62e552 100644
--- a/test/matchers/status/specific/toHaveBadGatewayStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveBadGatewayStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveBadGatewayStatus > using got > .not.toHaveBadGatewayStatus > fails when response have status code 502 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBadGatewayStatus()</intensity>
+
+Expected status code to not be 502 received:
+  <red>502</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 502,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveBadGatewayStatus > using got > .toHaveBadGatewayStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBadGatewayStatus()</intensity>
+
+Expected status code to be 502 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveBadRequestStatus.test.js.snapshot b/test/matchers/status/specific/toHaveBadRequestStatus.test.js.snapshot
index a33d7ef..1557023 100644
--- a/test/matchers/status/specific/toHaveBadRequestStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveBadRequestStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveBadRequestStatus > using got > .not.toHaveBadRequestStatus > fails when response have status code 400 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveBadRequestStatus()</intensity>
+
+Expected status code to not be 400 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveBadRequestStatus > using got > .toHaveBadRequestStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveBadRequestStatus()</intensity>
+
+Expected status code to be 400 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveConflictStatus.test.js.snapshot b/test/matchers/status/specific/toHaveConflictStatus.test.js.snapshot
index 5a1363a..d159c4a 100644
--- a/test/matchers/status/specific/toHaveConflictStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveConflictStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveConflictStatus > using got > .not.toHaveConflictStatus > fails when response have status code 409 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveConflictStatus()</intensity>
+
+Expected status code to not be 409 received:
+  <red>409</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 409,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveConflictStatus > using got > .toHaveConflictStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveConflictStatus()</intensity>
+
+Expected status code to be 409 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveCreatedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveCreatedStatus.test.js.snapshot
index 6a728ec..3ac9651 100644
--- a/test/matchers/status/specific/toHaveCreatedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveCreatedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveCreatedStatus > using got > .not.toHaveCreatedStatus > fails when response have status code 201 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveCreatedStatus()</intensity>
+
+Expected status code to not be 201 received:
+  <red>201</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 201,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveCreatedStatus > using got > .toHaveCreatedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveCreatedStatus()</intensity>
+
+Expected status code to be 201 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js.snapshot
index 245357d..2ed738d 100644
--- a/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveExpectationFailedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveExpectationFailedStatus > using got > .not.toHaveExpectationFailedStatus > fails when response have status code 417 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveExpectationFailedStatus()</intensity>
+
+Expected status code to not be 417 received:
+  <red>417</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 417,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveExpectationFailedStatus > using got > .toHaveExpectationFailedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveExpectationFailedStatus()</intensity>
+
+Expected status code to be 417 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js.snapshot b/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js.snapshot
index db91a05..d536b72 100644
--- a/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveFailedDependencyStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveFailedDependencyStatus > using got > .not.toHaveFailedDependencyStatus > fails when response have status code 424 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveFailedDependencyStatus()</intensity>
+
+Expected status code to not be 424 received:
+  <red>424</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 424,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveFailedDependencyStatus > using got > .toHaveFailedDependencyStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveFailedDependencyStatus()</intensity>
+
+Expected status code to be 424 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveForbiddenStatus.test.js.snapshot b/test/matchers/status/specific/toHaveForbiddenStatus.test.js.snapshot
index ac44473..3be48ce 100644
--- a/test/matchers/status/specific/toHaveForbiddenStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveForbiddenStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveForbiddenStatus > using got > .not.toHaveForbiddenStatus > fails when response have status code 403 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveForbiddenStatus()</intensity>
+
+Expected status code to not be 403 received:
+  <red>403</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 403,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveForbiddenStatus > using got > .toHaveForbiddenStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveForbiddenStatus()</intensity>
+
+Expected status code to be 403 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js.snapshot b/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js.snapshot
index b5b39ad..5ee1007 100644
--- a/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveGatewayTimeoutStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveGatewayTimeoutStatus > using got > .not.toHaveGatewayTimeoutStatus > fails when response have status code 504 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveGatewayTimeoutStatus()</intensity>
+
+Expected status code to not be 504 received:
+  <red>504</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 504,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveGatewayTimeoutStatus > using got > .toHaveGatewayTimeoutStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveGatewayTimeoutStatus()</intensity>
+
+Expected status code to be 504 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveGoneStatus.test.js.snapshot b/test/matchers/status/specific/toHaveGoneStatus.test.js.snapshot
index 788762b..bc463db 100644
--- a/test/matchers/status/specific/toHaveGoneStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveGoneStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveGoneStatus > using got > .not.toHaveGoneStatus > fails when response have status code 410 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveGoneStatus()</intensity>
+
+Expected status code to not be 410 received:
+  <red>410</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 410,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveGoneStatus > using got > .toHaveGoneStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveGoneStatus()</intensity>
+
+Expected status code to be 410 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js.snapshot
index 54d1052..96e424b 100644
--- a/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveHttpVersionNotSupportedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveHttpVersionNotSupportedStatus > using got > .not.toHaveHttpVersionNotSupportedStatus > fails when response have status code 505 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveHttpVersionNotSupportedStatus()</intensity>
+
+Expected status code to not be 505 received:
+  <red>505</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 505,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveHttpVersionNotSupportedStatus > using got > .toHaveHttpVersionNotSupportedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveHttpVersionNotSupportedStatus()</intensity>
+
+Expected status code to be 505 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveImATeapotStatus.test.js.snapshot b/test/matchers/status/specific/toHaveImATeapotStatus.test.js.snapshot
index 4e06104..48481e4 100644
--- a/test/matchers/status/specific/toHaveImATeapotStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveImATeapotStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveImATeapotStatus > using got > .not.toHaveImATeapotStatus > fails when response have status code 418 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveImATeapotStatus()</intensity>
+
+Expected status code to not be 418 received:
+  <red>418</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 418,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveImATeapotStatus > using got > .toHaveImATeapotStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveImATeapotStatus()</intensity>
+
+Expected status code to be 418 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js.snapshot b/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js.snapshot
index b06b5f2..86f4d6e 100644
--- a/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveInsufficientSpaceOnResourceStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveInsufficientSpaceOnResourceStatus > using got > .not.toHaveInsufficientSpaceOnResourceStatus > fails when response have status code 419 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveInsufficientSpaceOnResourceStatus()</intensity>
+
+Expected status code to not be 419 received:
+  <red>419</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 419,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveInsufficientSpaceOnResourceStatus > using got > .toHaveInsufficientSpaceOnResourceStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveInsufficientSpaceOnResourceStatus()</intensity>
+
+Expected status code to be 419 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js.snapshot b/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js.snapshot
index 83b20de..b46ca91 100644
--- a/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveInsufficientStorageStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveInsufficientStorageStatus > using got > .not.toHaveInsufficientStorageStatus > fails when response have status code 507 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveInsufficientStorageStatus()</intensity>
+
+Expected status code to not be 507 received:
+  <red>507</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 507,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveInsufficientStorageStatus > using got > .toHaveInsufficientStorageStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveInsufficientStorageStatus()</intensity>
+
+Expected status code to be 507 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js.snapshot b/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js.snapshot
index 9d35004..26b6e20 100644
--- a/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveInternalServerErrorStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveInternalServerErrorStatus > using got > .not.toHaveInternalServerErrorStatus > fails when response have status code 500 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveInternalServerErrorStatus()</intensity>
+
+Expected status code to not be 500 received:
+  <red>500</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 500,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveInternalServerErrorStatus > using got > .toHaveInternalServerErrorStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveInternalServerErrorStatus()</intensity>
+
+Expected status code to be 500 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js.snapshot
index b102322..796f193 100644
--- a/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveLengthRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveLengthRequiredStatus > using got > .not.toHaveLengthRequiredStatus > fails when response have status code 411 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveLengthRequiredStatus()</intensity>
+
+Expected status code to not be 411 received:
+  <red>411</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 411,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveLengthRequiredStatus > using got > .toHaveLengthRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveLengthRequiredStatus()</intensity>
+
+Expected status code to be 411 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveLockedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveLockedStatus.test.js.snapshot
index 28c99ab..034d43d 100644
--- a/test/matchers/status/specific/toHaveLockedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveLockedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveLockedStatus > using got > .not.toHaveLockedStatus > fails when response have status code 423 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveLockedStatus()</intensity>
+
+Expected status code to not be 423 received:
+  <red>423</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 423,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveLockedStatus > using got > .toHaveLockedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveLockedStatus()</intensity>
+
+Expected status code to be 423 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMethodFailureStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMethodFailureStatus.test.js.snapshot
index 10db0d3..eca1713 100644
--- a/test/matchers/status/specific/toHaveMethodFailureStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMethodFailureStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMethodFailureStatus > using got > .not.toHaveMethodFailureStatus > fails when response have status code 420 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMethodFailureStatus()</intensity>
+
+Expected status code to not be 420 received:
+  <red>420</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 420,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMethodFailureStatus > using got > .toHaveMethodFailureStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMethodFailureStatus()</intensity>
+
+Expected status code to be 420 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js.snapshot
index 09a426e..d5ffc9d 100644
--- a/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMethodNotAllowedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMethodNotAllowedStatus > using got > .not.toHaveMethodNotAllowedStatus > fails when response have status code 405 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMethodNotAllowedStatus()</intensity>
+
+Expected status code to not be 405 received:
+  <red>405</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 405,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMethodNotAllowedStatus > using got > .toHaveMethodNotAllowedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMethodNotAllowedStatus()</intensity>
+
+Expected status code to be 405 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js.snapshot
index de7bbd0..4140b81 100644
--- a/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMisdirectedRequestStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMisdirectedRequestStatus > using got > .not.toHaveMisdirectedRequestStatus > fails when response have status code 421 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMisdirectedRequestStatus()</intensity>
+
+Expected status code to not be 421 received:
+  <red>421</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 421,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMisdirectedRequestStatus > using got > .toHaveMisdirectedRequestStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMisdirectedRequestStatus()</intensity>
+
+Expected status code to be 421 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js.snapshot
index da41eb5..87d0258 100644
--- a/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMovedPermanentlyStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMovedPermanentlyStatus > using got > .not.toHaveMovedPermanentlyStatus > fails when response have status code 301 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMovedPermanentlyStatus()</intensity>
+
+Expected status code to not be 301 received:
+  <red>301</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 301,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMovedPermanentlyStatus > using got > .toHaveMovedPermanentlyStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMovedPermanentlyStatus()</intensity>
+
+Expected status code to be 301 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js.snapshot
index b169f7a..142f7af 100644
--- a/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMovedTemporarilyStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMovedTemporarilyStatus > using got > .not.toHaveMovedTemporarilyStatus > fails when response have status code 302 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMovedTemporarilyStatus()</intensity>
+
+Expected status code to not be 302 received:
+  <red>302</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 302,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMovedTemporarilyStatus > using got > .toHaveMovedTemporarilyStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMovedTemporarilyStatus()</intensity>
+
+Expected status code to be 302 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMultiStatusStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMultiStatusStatus.test.js.snapshot
index d930c5e..1f86799 100644
--- a/test/matchers/status/specific/toHaveMultiStatusStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMultiStatusStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMultiStatusStatus > using got > .not.toHaveMultiStatusStatus > fails when response have status code 207 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMultiStatusStatus()</intensity>
+
+Expected status code to not be 207 received:
+  <red>207</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 207,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMultiStatusStatus > using got > .toHaveMultiStatusStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMultiStatusStatus()</intensity>
+
+Expected status code to be 207 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js.snapshot b/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js.snapshot
index 53a43fd..4ae8a46 100644
--- a/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveMultipleChoicesStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveMultipleChoicesStatus > using got > .not.toHaveMultipleChoicesStatus > fails when response have status code 300 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveMultipleChoicesStatus()</intensity>
+
+Expected status code to not be 300 received:
+  <red>300</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 300,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveMultipleChoicesStatus > using got > .toHaveMultipleChoicesStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveMultipleChoicesStatus()</intensity>
+
+Expected status code to be 300 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js.snapshot
index dce332f..3149421 100644
--- a/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNetworkAuthenticationRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNetworkAuthenticationRequiredStatus > using got > .not.toHaveNetworkAuthenticationRequiredStatus > fails when response have status code 511 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNetworkAuthenticationRequiredStatus()</intensity>
+
+Expected status code to not be 511 received:
+  <red>511</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 511,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveNetworkAuthenticationRequiredStatus > using got > .toHaveNetworkAuthenticationRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNetworkAuthenticationRequiredStatus()</intensity>
+
+Expected status code to be 511 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNoContentStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNoContentStatus.test.js.snapshot
index 0326a05..9e91b70 100644
--- a/test/matchers/status/specific/toHaveNoContentStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNoContentStatus.test.js.snapshot
@@ -35,3 +35,41 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNoContentStatus > using got > .not.toHaveNoContentStatus > fails when response have status code 204 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNoContentStatus()</intensity>
+
+Expected status code to not be 204 received:
+  <red>204</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 204,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveNoContentStatus > using got > .toHaveNoContentStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNoContentStatus()</intensity>
+
+Expected status code to be 204 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js.snapshot
index 2e659d1..cea56e0 100644
--- a/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNonAuthoritativeInformationStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNonAuthoritativeInformationStatus > using got > .not.toHaveNonAuthoritativeInformationStatus > fails when response have status code 203 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNonAuthoritativeInformationStatus()</intensity>
+
+Expected status code to not be 203 received:
+  <red>203</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 203,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveNonAuthoritativeInformationStatus > using got > .toHaveNonAuthoritativeInformationStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNonAuthoritativeInformationStatus()</intensity>
+
+Expected status code to be 203 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js.snapshot
index a3b5142..4e88f72 100644
--- a/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNotAcceptableStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNotAcceptableStatus > using got > .not.toHaveNotAcceptableStatus > fails when response have status code 406 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNotAcceptableStatus()</intensity>
+
+Expected status code to not be 406 received:
+  <red>406</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 406,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveNotAcceptableStatus > using got > .toHaveNotAcceptableStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNotAcceptableStatus()</intensity>
+
+Expected status code to be 406 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNotFoundStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNotFoundStatus.test.js.snapshot
index df1f027..cf0e49c 100644
--- a/test/matchers/status/specific/toHaveNotFoundStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNotFoundStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNotFoundStatus > using got > .not.toHaveNotFoundStatus > fails when response have status code 404 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNotFoundStatus()</intensity>
+
+Expected status code to not be 404 received:
+  <red>404</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 404,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveNotFoundStatus > using got > .toHaveNotFoundStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNotFoundStatus()</intensity>
+
+Expected status code to be 404 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNotImplementedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNotImplementedStatus.test.js.snapshot
index 08f4f4d..1698a73 100644
--- a/test/matchers/status/specific/toHaveNotImplementedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNotImplementedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNotImplementedStatus > using got > .not.toHaveNotImplementedStatus > fails when response have status code 501 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNotImplementedStatus()</intensity>
+
+Expected status code to not be 501 received:
+  <red>501</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 501,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveNotImplementedStatus > using got > .toHaveNotImplementedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNotImplementedStatus()</intensity>
+
+Expected status code to be 501 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveNotModifiedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveNotModifiedStatus.test.js.snapshot
index efb7d20..e171f16 100644
--- a/test/matchers/status/specific/toHaveNotModifiedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveNotModifiedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveNotModifiedStatus > using got > .not.toHaveNotModifiedStatus > fails when response have status code 304 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveNotModifiedStatus()</intensity>
+
+Expected status code to not be 304 received:
+  <red>304</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 304,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveNotModifiedStatus > using got > .toHaveNotModifiedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveNotModifiedStatus()</intensity>
+
+Expected status code to be 304 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveOkStatus.test.js.snapshot b/test/matchers/status/specific/toHaveOkStatus.test.js.snapshot
index fb590fa..193a088 100644
--- a/test/matchers/status/specific/toHaveOkStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveOkStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveOkStatus > using got > .not.toHaveOkStatus > fails when response have status code 200 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveOkStatus()</intensity>
+
+Expected status code to not be 200 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveOkStatus > using got > .toHaveOkStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveOkStatus()</intensity>
+
+Expected status code to be 200 received:
+  <red>400</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 400,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHavePartialContentStatus.test.js.snapshot b/test/matchers/status/specific/toHavePartialContentStatus.test.js.snapshot
index 2bc1c82..9aa9b85 100644
--- a/test/matchers/status/specific/toHavePartialContentStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHavePartialContentStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHavePartialContentStatus > using got > .not.toHavePartialContentStatus > fails when response have status code 206 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHavePartialContentStatus()</intensity>
+
+Expected status code to not be 206 received:
+  <red>206</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 206,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHavePartialContentStatus > using got > .toHavePartialContentStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHavePartialContentStatus()</intensity>
+
+Expected status code to be 206 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js.snapshot
index 0a9a000..b231f75 100644
--- a/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHavePaymentRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHavePaymentRequiredStatus > using got > .not.toHavePaymentRequiredStatus > fails when response have status code 402 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHavePaymentRequiredStatus()</intensity>
+
+Expected status code to not be 402 received:
+  <red>402</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 402,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHavePaymentRequiredStatus > using got > .toHavePaymentRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHavePaymentRequiredStatus()</intensity>
+
+Expected status code to be 402 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js.snapshot b/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js.snapshot
index 82b1074..bcc184a 100644
--- a/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHavePermanentRedirectStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHavePermanentRedirectStatus > using got > .not.toHavePermanentRedirectStatus > fails when response have status code 308 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHavePermanentRedirectStatus()</intensity>
+
+Expected status code to not be 308 received:
+  <red>308</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 308,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHavePermanentRedirectStatus > using got > .toHavePermanentRedirectStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHavePermanentRedirectStatus()</intensity>
+
+Expected status code to be 308 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js.snapshot b/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js.snapshot
index fe0f866..3d89a05 100644
--- a/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHavePreconditionFailedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHavePreconditionFailedStatus > using got > .not.toHavePreconditionFailedStatus > fails when response have status code 412 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHavePreconditionFailedStatus()</intensity>
+
+Expected status code to not be 412 received:
+  <red>412</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 412,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHavePreconditionFailedStatus > using got > .toHavePreconditionFailedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHavePreconditionFailedStatus()</intensity>
+
+Expected status code to be 412 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js.snapshot
index 4c8461d..5d95e63 100644
--- a/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHavePreconditionRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHavePreconditionRequiredStatus > using got > .not.toHavePreconditionRequiredStatus > fails when response have status code 428 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHavePreconditionRequiredStatus()</intensity>
+
+Expected status code to not be 428 received:
+  <red>428</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 428,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHavePreconditionRequiredStatus > using got > .toHavePreconditionRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHavePreconditionRequiredStatus()</intensity>
+
+Expected status code to be 428 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js.snapshot
index 81b0b7e..4d90b78 100644
--- a/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveProxyAuthenticationRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveProxyAuthenticationRequiredStatus > using got > .not.toHaveProxyAuthenticationRequiredStatus > fails when response have status code 407 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveProxyAuthenticationRequiredStatus()</intensity>
+
+Expected status code to not be 407 received:
+  <red>407</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 407,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveProxyAuthenticationRequiredStatus > using got > .toHaveProxyAuthenticationRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveProxyAuthenticationRequiredStatus()</intensity>
+
+Expected status code to be 407 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js.snapshot b/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js.snapshot
index c02a218..dec6529 100644
--- a/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveRequestHeaderFieldsTooLargeStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveRequestHeaderFieldsTooLargeStatus > using got > .not.toHaveRequestHeaderFieldsTooLargeStatus > fails when response have status code 431 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveRequestHeaderFieldsTooLargeStatus()</intensity>
+
+Expected status code to not be 431 received:
+  <red>431</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 431,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveRequestHeaderFieldsTooLargeStatus > using got > .toHaveRequestHeaderFieldsTooLargeStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveRequestHeaderFieldsTooLargeStatus()</intensity>
+
+Expected status code to be 431 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js.snapshot b/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js.snapshot
index 8e0414d..b069f2a 100644
--- a/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveRequestTimeoutStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveRequestTimeoutStatus > using got > .not.toHaveRequestTimeoutStatus > fails when response have status code 408 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveRequestTimeoutStatus()</intensity>
+
+Expected status code to not be 408 received:
+  <red>408</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 408,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveRequestTimeoutStatus > using got > .toHaveRequestTimeoutStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveRequestTimeoutStatus()</intensity>
+
+Expected status code to be 408 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js.snapshot b/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js.snapshot
index d311fe7..d56efeb 100644
--- a/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveRequestTooLongStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveRequestTooLongStatus > using got > .not.toHaveRequestTooLongStatus > fails when response have status code 413 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveRequestTooLongStatus()</intensity>
+
+Expected status code to not be 413 received:
+  <red>413</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 413,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveRequestTooLongStatus > using got > .toHaveRequestTooLongStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveRequestTooLongStatus()</intensity>
+
+Expected status code to be 413 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js.snapshot b/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js.snapshot
index 828daf1..d63b955 100644
--- a/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveRequestUriTooLongStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveRequestUriTooLongStatus > using got > .not.toHaveRequestUriTooLongStatus > fails when response have status code 414 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveRequestUriTooLongStatus()</intensity>
+
+Expected status code to not be 414 received:
+  <red>414</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 414,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveRequestUriTooLongStatus > using got > .toHaveRequestUriTooLongStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveRequestUriTooLongStatus()</intensity>
+
+Expected status code to be 414 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js.snapshot b/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js.snapshot
index 6efbac2..f65c9a8 100644
--- a/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveRequestedRangeNotSatisfiableStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveRequestedRangeNotSatisfiableStatus > using got > .not.toHaveRequestedRangeNotSatisfiableStatus > fails when response have status code 416 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveRequestedRangeNotSatisfiableStatus()</intensity>
+
+Expected status code to not be 416 received:
+  <red>416</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 416,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveRequestedRangeNotSatisfiableStatus > using got > .toHaveRequestedRangeNotSatisfiableStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveRequestedRangeNotSatisfiableStatus()</intensity>
+
+Expected status code to be 416 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveResetContentStatus.test.js.snapshot b/test/matchers/status/specific/toHaveResetContentStatus.test.js.snapshot
index 2402c4f..de62fd6 100644
--- a/test/matchers/status/specific/toHaveResetContentStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveResetContentStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveResetContentStatus > using got > .not.toHaveResetContentStatus > fails when response have status code 205 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveResetContentStatus()</intensity>
+
+Expected status code to not be 205 received:
+  <red>205</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 205,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveResetContentStatus > using got > .toHaveResetContentStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveResetContentStatus()</intensity>
+
+Expected status code to be 205 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveSeeOtherStatus.test.js.snapshot b/test/matchers/status/specific/toHaveSeeOtherStatus.test.js.snapshot
index 106a7ab..2ebcfb9 100644
--- a/test/matchers/status/specific/toHaveSeeOtherStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveSeeOtherStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveSeeOtherStatus > using got > .not.toHaveSeeOtherStatus > fails when response have status code 303 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveSeeOtherStatus()</intensity>
+
+Expected status code to not be 303 received:
+  <red>303</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 303,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveSeeOtherStatus > using got > .toHaveSeeOtherStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveSeeOtherStatus()</intensity>
+
+Expected status code to be 303 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js.snapshot b/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js.snapshot
index 45a24e3..23c64db 100644
--- a/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveServiceUnavailableStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveServiceUnavailableStatus > using got > .not.toHaveServiceUnavailableStatus > fails when response have status code 503 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveServiceUnavailableStatus()</intensity>
+
+Expected status code to not be 503 received:
+  <red>503</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 503,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveServiceUnavailableStatus > using got > .toHaveServiceUnavailableStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveServiceUnavailableStatus()</intensity>
+
+Expected status code to be 503 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js.snapshot b/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js.snapshot
index 0c7ffd6..c908260 100644
--- a/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveSwitchingProtocolsStatus.test.js.snapshot
@@ -35,3 +35,41 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveSwitchingProtocolsStatus > using got > .not.toHaveSwitchingProtocolsStatus > fails when response have status code 101 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveSwitchingProtocolsStatus()</intensity>
+
+Expected status code to not be 101 received:
+  <red>101</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 101,
+  "headers": {
+    "connection": "keep-alive"
+  },
+  "body": ""
+}
+`;
+
+exports[`(.not).toHaveSwitchingProtocolsStatus > using got > .toHaveSwitchingProtocolsStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveSwitchingProtocolsStatus()</intensity>
+
+Expected status code to be 101 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js.snapshot b/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js.snapshot
index 2503038..59b2cee 100644
--- a/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveTemporaryRedirectStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveTemporaryRedirectStatus > using got > .not.toHaveTemporaryRedirectStatus > fails when response have status code 307 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveTemporaryRedirectStatus()</intensity>
+
+Expected status code to not be 307 received:
+  <red>307</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 307,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveTemporaryRedirectStatus > using got > .toHaveTemporaryRedirectStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveTemporaryRedirectStatus()</intensity>
+
+Expected status code to be 307 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js.snapshot b/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js.snapshot
index 31ed038..1a0f12b 100644
--- a/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveTooManyRequestsStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveTooManyRequestsStatus > using got > .not.toHaveTooManyRequestsStatus > fails when response have status code 429 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveTooManyRequestsStatus()</intensity>
+
+Expected status code to not be 429 received:
+  <red>429</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 429,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveTooManyRequestsStatus > using got > .toHaveTooManyRequestsStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveTooManyRequestsStatus()</intensity>
+
+Expected status code to be 429 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js.snapshot
index 8343932..7e2cda4 100644
--- a/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUnauthorizedStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUnauthorizedStatus > using got > .not.toHaveUnauthorizedStatus > fails when response have status code 401 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUnauthorizedStatus()</intensity>
+
+Expected status code to not be 401 received:
+  <red>401</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 401,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUnauthorizedStatus > using got > .toHaveUnauthorizedStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUnauthorizedStatus()</intensity>
+
+Expected status code to be 401 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js.snapshot
index 605daeb..7cf42d4 100644
--- a/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUnavailableForLegalReasonsStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUnavailableForLegalReasonsStatus > using got > .not.toHaveUnavailableForLegalReasonsStatus > fails when response have status code 451 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUnavailableForLegalReasonsStatus()</intensity>
+
+Expected status code to not be 451 received:
+  <red>451</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 451,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUnavailableForLegalReasonsStatus > using got > .toHaveUnavailableForLegalReasonsStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUnavailableForLegalReasonsStatus()</intensity>
+
+Expected status code to be 451 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js.snapshot
index 25420f3..1e422aa 100644
--- a/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUnprocessableEntityStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUnprocessableEntityStatus > using got > .not.toHaveUnprocessableEntityStatus > fails when response have status code 422 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUnprocessableEntityStatus()</intensity>
+
+Expected status code to not be 422 received:
+  <red>422</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 422,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUnprocessableEntityStatus > using got > .toHaveUnprocessableEntityStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUnprocessableEntityStatus()</intensity>
+
+Expected status code to be 422 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js.snapshot
index 42e1a73..71e0b4e 100644
--- a/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUnsupportedMediaTypeStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUnsupportedMediaTypeStatus > using got > .not.toHaveUnsupportedMediaTypeStatus > fails when response have status code 415 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUnsupportedMediaTypeStatus()</intensity>
+
+Expected status code to not be 415 received:
+  <red>415</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 415,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUnsupportedMediaTypeStatus > using got > .toHaveUnsupportedMediaTypeStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUnsupportedMediaTypeStatus()</intensity>
+
+Expected status code to be 415 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js.snapshot
index 54221c9..e8a559d 100644
--- a/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUpgradeRequiredStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUpgradeRequiredStatus > using got > .not.toHaveUpgradeRequiredStatus > fails when response have status code 426 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUpgradeRequiredStatus()</intensity>
+
+Expected status code to not be 426 received:
+  <red>426</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 426,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUpgradeRequiredStatus > using got > .toHaveUpgradeRequiredStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUpgradeRequiredStatus()</intensity>
+
+Expected status code to be 426 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
diff --git a/test/matchers/status/specific/toHaveUseProxyStatus.test.js.snapshot b/test/matchers/status/specific/toHaveUseProxyStatus.test.js.snapshot
index 764b382..aa8554b 100644
--- a/test/matchers/status/specific/toHaveUseProxyStatus.test.js.snapshot
+++ b/test/matchers/status/specific/toHaveUseProxyStatus.test.js.snapshot
@@ -37,3 +37,43 @@ response is:
   "body": {}
 }
 `;
+
+exports[`(.not).toHaveUseProxyStatus > using got > .not.toHaveUseProxyStatus > fails when response have status code 305 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).not.toHaveUseProxyStatus()</intensity>
+
+Expected status code to not be 305 received:
+  <red>305</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 305,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;
+
+exports[`(.not).toHaveUseProxyStatus > using got > .toHaveUseProxyStatus > fails when response have other status code 1`] = `
+<dim>expect(</intensity><red>received</color><dim>).toHaveUseProxyStatus()</intensity>
+
+Expected status code to be 305 received:
+  <red>200</color>
+
+------------
+response is:
+{
+  "url": "http://127.0.0.1:54607/status",
+  "status": 200,
+  "headers": {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": "2",
+    "connection": "keep-alive"
+  },
+  "body": "{}"
+}
+`;

From e3c330bc7b1995a94ae643d528fac75cd4c10c26 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:30:37 +0300
Subject: [PATCH 12/14] docs: Add `got` docs

---
 README.md | 41 +++++++++++++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 2391b28..cbe5481 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 <div align="center">
   <h1>Expect HTTP Client Matchers</h1>
 
-Additional expect matchers for http clients (e.g. Axios), supports `jest`, `vitest`, `expect`.
+Additional expect matchers for http clients (e.g. Axios, got), supports `jest`, `vitest`, `expect`.
 
 </div>
 
@@ -17,6 +17,9 @@ Additional expect matchers for http clients (e.g. Axios), supports `jest`, `vite
       - [Typescript](#typescript-1)
     - [Jest](#jest)
       - [Typescript](#typescript-2)
+- [HTTP Clients](#http-clients)
+  - [Axios](#axios)
+  - [Got](#got)
 - [Asymmetric matchers](#asymmetric-matchers)
 - [API](#api)
   - [.toBeSuccessful()](#tobesuccessful)
@@ -241,9 +244,19 @@ test('passes when using an asymmetrical matcher', () => {
 });
 ```
 
-## Notes
+## HTTP Clients
 
-### Axios reject on unsuccessful status code
+The supported HTTP clients currently are `axios` and `got`.
+
+There are plan to support more clients in the future and user provided clients
+
+For best experience, you should disable throwing on unsuccessful status code,
+you should look at the specific client section for more information if it's needed
+
+
+### Axios
+
+When using `axios` client, you should disable throwing on unsuccessful status code
 
 By default `axios` throws error on error status code, this means that you will need to do the following which is ugly and have many problems:
 
@@ -270,7 +283,7 @@ const response = await axios.get('http://some-page.com/this-will-return-400');
 expect(response).not.toBeSuccessful();
 ```
 
-You need to do:
+You need to do **one of the following**:
 ```js
 // Don't throw an error on un-successful status code for ALL axios clients
 axios.defaults.validateStatus = () => true;
@@ -288,6 +301,26 @@ all the examples assume you have:
 axios.defaults.validateStatus = () => true;
 ```
 
+### Got
+
+When using `got`, you should disable throwing on unsuccessful status codes as well
+
+At the moment, `got` does not allow globally disabling throwing on unsuccessful status codes, you will need to do it per client/request
+```js
+import got from 'got';
+
+// Use this client for all requests
+const yourClient = got.extend({
+  // Don't throw on error
+  throwHttpErrors: false,
+  
+  // I recommend disabling retry on failure as well
+  // retry: {
+  //   limit: 0
+  // }
+});
+```
+
 ## API
 
 #### .toBeSuccessful()

From e0018acdba4178da9e22f588bc3c596b43217ff3 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 20:37:27 +0300
Subject: [PATCH 13/14] docs: Add got troubleshooting

---
 README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/README.md b/README.md
index cbe5481..1e49f58 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,11 @@ Additional expect matchers for http clients (e.g. Axios, got), supports `jest`,
       - [Typescript](#typescript-2)
 - [HTTP Clients](#http-clients)
   - [Axios](#axios)
+    - [Setup](#setup) 
   - [Got](#got)
+    - [Setup](#setup-1)
+    - [Troubleshooting](#troubleshooting)
+      - [Error: _The `searchParameters` option does not exist. Use `searchParams` instead._](#error-_the-searchparameters-option-does-not-exist-use-searchparams-instead_)
 - [Asymmetric matchers](#asymmetric-matchers)
 - [API](#api)
   - [.toBeSuccessful()](#tobesuccessful)
@@ -303,6 +307,8 @@ axios.defaults.validateStatus = () => true;
 
 ### Got
 
+#### Setup
+
 When using `got`, you should disable throwing on unsuccessful status codes as well
 
 At the moment, `got` does not allow globally disabling throwing on unsuccessful status codes, you will need to do it per client/request
@@ -321,6 +327,15 @@ const yourClient = got.extend({
 });
 ```
 
+#### Troubleshooting
+
+##### Error: _The `searchParameters` option does not exist. Use `searchParams` instead._
+
+This is due to `jest-matcher-utils` bug (which `expect` and we use under the hood) when printing the request it evaluates every property getter
+And `got` has a getter for `searchParameters` which throw an error as it's deprecated
+
+See more here: [jest/jest#15280](https://github.com/jestjs/jest/issues/15280)
+
 ## API
 
 #### .toBeSuccessful()

From f4ea33e22e02bd74185613b3234b45f8f3a6b787 Mon Sep 17 00:00:00 2001
From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com>
Date: Mon, 26 Aug 2024 21:06:11 +0300
Subject: [PATCH 14/14] docs: revert extra spacing

---
 README.md | 172 +++++++++++++++++++++++++++---------------------------
 1 file changed, 86 insertions(+), 86 deletions(-)

diff --git a/README.md b/README.md
index 2a78718..77a1a2c 100644
--- a/README.md
+++ b/README.md
@@ -12,87 +12,87 @@ Additional expect matchers for http clients (e.g. Axios, got, or custom), suppor
 - [Installation](#installation)
 - [Setup](#setup)
     - [Vanilla `expect`](#vanilla-expect)
-        - [Typescript](#typescript)
+      - [Typescript](#typescript)
     - [Vitest](#vitest)
-        - [Typescript](#typescript-1)
+      - [Typescript](#typescript-1)
     - [Jest](#jest)
-        - [Typescript](#typescript-2)
+      - [Typescript](#typescript-2)
 - [Asymmetric matchers](#asymmetric-matchers)
 - [HTTP Clients](#http-clients)
-    - [Axios](#axios)
-        - [Setup](#setup)
+  - [Axios](#axios)
+    - [Setup](#setup)
     - [Got](#got)
-        - [Setup](#setup-1)
-        - [Troubleshooting](#troubleshooting)
-            - [Error: _The `searchParameters` option does not exist. Use `searchParams` instead._](#error-_the-searchparameters-option-does-not-exist-use-searchparams-instead_)
-    - [Custom HTTP Client](#custom-http-client)
+      - [Setup](#setup-1)
+      - [Troubleshooting](#troubleshooting)
+        - [Error: _The `searchParameters` option does not exist. Use `searchParams` instead._](#error-_the-searchparameters-option-does-not-exist-use-searchparams-instead_)
+  - [Custom HTTP Client](#custom-http-client)
 - [Configure](#configure)
 - [API](#api)
-    - [.toBeSuccessful()](#tobesuccessful)
-    - [.toHave2xxStatus()](#tohave2xxstatus)
-    - [.toHave3xxStatus()](#tohave3xxstatus)
-    - [.toHave4xxStatus()](#tohave4xxstatus)
-    - [.toHave5xxStatus()](#tohave5xxstatus)
-    - [.toHaveStatus(`<status code>`)](#tohavestatusstatus-code)
-    - [Specific Status](#specific-status)
-        - [.toHaveSwitchingProtocolsStatus()](#tohaveswitchingprotocolsstatus)
-        - [.toHaveOkStatus()](#tohaveokstatus)
-        - [.toHaveCreatedStatus()](#tohavecreatedstatus)
-        - [.toHaveAcceptedStatus()](#tohaveacceptedstatus)
-        - [.toHaveNonAuthoritativeInformationStatus()](#tohavenonauthoritativeinformationstatus)
-        - [.toHaveNoContentStatus()](#tohavenocontentstatus)
-        - [.toHaveResetContentStatus()](#tohaveresetcontentstatus)
-        - [.toHavePartialContentStatus()](#tohavepartialcontentstatus)
-        - [.toHaveMultiStatusStatus()](#tohavemultistatusstatus)
-        - [.toHaveMultipleChoicesStatus()](#tohavemultiplechoicesstatus)
-        - [.toHaveMovedPermanentlyStatus()](#tohavemovedpermanentlystatus)
-        - [.toHaveMovedTemporarilyStatus()](#tohavemovedtemporarilystatus)
-        - [.toHaveSeeOtherStatus()](#tohaveseeotherstatus)
-        - [.toHaveNotModifiedStatus()](#tohavenotmodifiedstatus)
-        - [.toHaveUseProxyStatus()](#tohaveuseproxystatus)
-        - [.toHaveTemporaryRedirectStatus()](#tohavetemporaryredirectstatus)
-        - [.toHavePermanentRedirectStatus()](#tohavepermanentredirectstatus)
-        - [.toHaveBadRequestStatus()](#tohavebadrequeststatus)
-        - [.toHaveUnauthorizedStatus()](#tohaveunauthorizedstatus)
-        - [.toHavePaymentRequiredStatus()](#tohavepaymentrequiredstatus)
-        - [.toHaveForbiddenStatus()](#tohaveforbiddenstatus)
-        - [.toHaveNotFoundStatus()](#tohavenotfoundstatus)
-        - [.toHaveMethodNotAllowedStatus()](#tohavemethodnotallowedstatus)
-        - [.toHaveNotAcceptableStatus()](#tohavenotacceptablestatus)
-        - [.toHaveProxyAuthenticationRequiredStatus()](#tohaveproxyauthenticationrequiredstatus)
-        - [.toHaveRequestTimeoutStatus()](#tohaverequesttimeoutstatus)
-        - [.toHaveConflictStatus()](#tohaveconflictstatus)
-        - [.toHaveGoneStatus()](#tohavegonestatus)
-        - [.toHaveLengthRequiredStatus()](#tohavelengthrequiredstatus)
-        - [.toHavePreconditionFailedStatus()](#tohavepreconditionfailedstatus)
-        - [.toHaveRequestTooLongStatus()](#tohaverequesttoolongstatus)
-        - [.toHaveRequestUriTooLongStatus()](#tohaverequesturitoolongstatus)
-        - [.toHaveUnsupportedMediaTypeStatus()](#tohaveunsupportedmediatypestatus)
-        - [.toHaveRequestedRangeNotSatisfiableStatus()](#tohaverequestedrangenotsatisfiablestatus)
-        - [.toHaveExpectationFailedStatus()](#tohaveexpectationfailedstatus)
-        - [.toHaveImATeapotStatus()](#tohaveimateapotstatus)
-        - [.toHaveInsufficientSpaceOnResourceStatus()](#tohaveinsufficientspaceonresourcestatus)
-        - [.toHaveMethodFailureStatus()](#tohavemethodfailurestatus)
-        - [.toHaveMisdirectedRequestStatus()](#tohavemisdirectedrequeststatus)
-        - [.toHaveUnprocessableEntityStatus()](#tohaveunprocessableentitystatus)
-        - [.toHaveLockedStatus()](#tohavelockedstatus)
-        - [.toHaveFailedDependencyStatus()](#tohavefaileddependencystatus)
-        - [.toHaveUpgradeRequiredStatus()](#tohaveupgraderequiredstatus)
-        - [.toHavePreconditionRequiredStatus()](#tohavepreconditionrequiredstatus)
-        - [.toHaveTooManyRequestsStatus()](#tohavetoomanyrequestsstatus)
-        - [.toHaveRequestHeaderFieldsTooLargeStatus()](#tohaverequestheaderfieldstoolargestatus)
-        - [.toHaveUnavailableForLegalReasonsStatus()](#tohaveunavailableforlegalreasonsstatus)
-        - [.toHaveInternalServerErrorStatus()](#tohaveinternalservererrorstatus)
-        - [.toHaveNotImplementedStatus()](#tohavenotimplementedstatus)
-        - [.toHaveBadGatewayStatus()](#tohavebadgatewaystatus)
-        - [.toHaveServiceUnavailableStatus()](#tohaveserviceunavailablestatus)
-        - [.toHaveGatewayTimeoutStatus()](#tohavegatewaytimeoutstatus)
-        - [.toHaveHttpVersionNotSupportedStatus()](#tohavehttpversionnotsupportedstatus)
-        - [.toHaveInsufficientStorageStatus()](#tohaveinsufficientstoragestatus)
-        - [.toHaveNetworkAuthenticationRequiredStatus()](#tohavenetworkauthenticationrequiredstatus)
-    - [.toHaveHeader(`<header name>`[, `<header value>`])](#tohaveheaderheader-name-header-value)
-    - [.toHaveBodyEquals(`<body>`)](#tohavebodyequalsbody)
-    - [.toHaveBodyMatchObject(`<body>`)](#tohavebodymatchobjectbody)
+  - [.toBeSuccessful()](#tobesuccessful)
+  - [.toHave2xxStatus()](#tohave2xxstatus)
+  - [.toHave3xxStatus()](#tohave3xxstatus) 
+  - [.toHave4xxStatus()](#tohave4xxstatus)
+  - [.toHave5xxStatus()](#tohave5xxstatus)
+  - [.toHaveStatus(`<status code>`)](#tohavestatusstatus-code)
+  - [Specific Status](#specific-status)
+    - [.toHaveSwitchingProtocolsStatus()](#tohaveswitchingprotocolsstatus)
+    - [.toHaveOkStatus()](#tohaveokstatus)
+    - [.toHaveCreatedStatus()](#tohavecreatedstatus)
+    - [.toHaveAcceptedStatus()](#tohaveacceptedstatus)
+    - [.toHaveNonAuthoritativeInformationStatus()](#tohavenonauthoritativeinformationstatus)
+    - [.toHaveNoContentStatus()](#tohavenocontentstatus)
+    - [.toHaveResetContentStatus()](#tohaveresetcontentstatus)
+    - [.toHavePartialContentStatus()](#tohavepartialcontentstatus)
+    - [.toHaveMultiStatusStatus()](#tohavemultistatusstatus)
+    - [.toHaveMultipleChoicesStatus()](#tohavemultiplechoicesstatus)
+    - [.toHaveMovedPermanentlyStatus()](#tohavemovedpermanentlystatus)
+    - [.toHaveMovedTemporarilyStatus()](#tohavemovedtemporarilystatus)
+    - [.toHaveSeeOtherStatus()](#tohaveseeotherstatus)
+    - [.toHaveNotModifiedStatus()](#tohavenotmodifiedstatus)
+    - [.toHaveUseProxyStatus()](#tohaveuseproxystatus)
+    - [.toHaveTemporaryRedirectStatus()](#tohavetemporaryredirectstatus)
+    - [.toHavePermanentRedirectStatus()](#tohavepermanentredirectstatus)
+    - [.toHaveBadRequestStatus()](#tohavebadrequeststatus)
+    - [.toHaveUnauthorizedStatus()](#tohaveunauthorizedstatus)
+    - [.toHavePaymentRequiredStatus()](#tohavepaymentrequiredstatus)
+    - [.toHaveForbiddenStatus()](#tohaveforbiddenstatus)
+    - [.toHaveNotFoundStatus()](#tohavenotfoundstatus)
+    - [.toHaveMethodNotAllowedStatus()](#tohavemethodnotallowedstatus)
+    - [.toHaveNotAcceptableStatus()](#tohavenotacceptablestatus)
+    - [.toHaveProxyAuthenticationRequiredStatus()](#tohaveproxyauthenticationrequiredstatus)
+    - [.toHaveRequestTimeoutStatus()](#tohaverequesttimeoutstatus)
+    - [.toHaveConflictStatus()](#tohaveconflictstatus)
+    - [.toHaveGoneStatus()](#tohavegonestatus)
+    - [.toHaveLengthRequiredStatus()](#tohavelengthrequiredstatus)
+    - [.toHavePreconditionFailedStatus()](#tohavepreconditionfailedstatus)
+    - [.toHaveRequestTooLongStatus()](#tohaverequesttoolongstatus)
+    - [.toHaveRequestUriTooLongStatus()](#tohaverequesturitoolongstatus)
+    - [.toHaveUnsupportedMediaTypeStatus()](#tohaveunsupportedmediatypestatus)
+    - [.toHaveRequestedRangeNotSatisfiableStatus()](#tohaverequestedrangenotsatisfiablestatus)
+    - [.toHaveExpectationFailedStatus()](#tohaveexpectationfailedstatus)
+    - [.toHaveImATeapotStatus()](#tohaveimateapotstatus)
+    - [.toHaveInsufficientSpaceOnResourceStatus()](#tohaveinsufficientspaceonresourcestatus)
+    - [.toHaveMethodFailureStatus()](#tohavemethodfailurestatus)
+    - [.toHaveMisdirectedRequestStatus()](#tohavemisdirectedrequeststatus)
+    - [.toHaveUnprocessableEntityStatus()](#tohaveunprocessableentitystatus)
+    - [.toHaveLockedStatus()](#tohavelockedstatus)
+    - [.toHaveFailedDependencyStatus()](#tohavefaileddependencystatus)
+    - [.toHaveUpgradeRequiredStatus()](#tohaveupgraderequiredstatus)
+    - [.toHavePreconditionRequiredStatus()](#tohavepreconditionrequiredstatus)
+    - [.toHaveTooManyRequestsStatus()](#tohavetoomanyrequestsstatus)
+    - [.toHaveRequestHeaderFieldsTooLargeStatus()](#tohaverequestheaderfieldstoolargestatus)
+    - [.toHaveUnavailableForLegalReasonsStatus()](#tohaveunavailableforlegalreasonsstatus)
+    - [.toHaveInternalServerErrorStatus()](#tohaveinternalservererrorstatus)
+    - [.toHaveNotImplementedStatus()](#tohavenotimplementedstatus)
+    - [.toHaveBadGatewayStatus()](#tohavebadgatewaystatus)
+    - [.toHaveServiceUnavailableStatus()](#tohaveserviceunavailablestatus)
+    - [.toHaveGatewayTimeoutStatus()](#tohavegatewaytimeoutstatus)
+    - [.toHaveHttpVersionNotSupportedStatus()](#tohavehttpversionnotsupportedstatus)
+    - [.toHaveInsufficientStorageStatus()](#tohaveinsufficientstoragestatus)
+    - [.toHaveNetworkAuthenticationRequiredStatus()](#tohavenetworkauthenticationrequiredstatus)
+  - [.toHaveHeader(`<header name>`[, `<header value>`])](#tohaveheaderheader-name-header-value)
+  - [.toHaveBodyEquals(`<body>`)](#tohavebodyequalsbody)
+  - [.toHaveBodyMatchObject(`<body>`)](#tohavebodymatchobjectbody)
 
 
 ## Installation
@@ -1486,13 +1486,13 @@ header names are case-insensitive
 
 ```js
 test('passes when response header match the expected header', async () => {
-    const response = await axios.get('https://httpstat.us/200');
-    expect(response).toHaveHeader('content-type');
+  const response = await axios.get('https://httpstat.us/200');
+  expect(response).toHaveHeader('content-type');
 });
 
 test('passes when using .toHaveHeader() with expected value', async () => {
-    const response = await axios.get('http://example.com');
-    expect(response).toHaveHeader('Accept', 'text/html; UTF-8');
+  const response = await axios.get('http://example.com');
+  expect(response).toHaveHeader('Accept', 'text/html; UTF-8');
 });
 ```
 
@@ -1502,13 +1502,13 @@ Use `.toHaveBodyEquals` when checking if response body is equal to the expected
 
 ```js
 test('passes when response body match the expected body', async () => {
-    const response = await axios.get('https://httpstat.us/200');
-    expect(response).toHaveBodyEquals('200 OK');
+  const response = await axios.get('https://httpstat.us/200');
+  expect(response).toHaveBodyEquals('200 OK');
 });
 
 test('passes when using .not.toHaveBodyEquals() with different body', async () => {
-    const response = await axios.get('https://httpstat.us/200');
-    expect(response).not.toHaveBodyEquals('404 NOT FOUND');
+  const response = await axios.get('https://httpstat.us/200');
+  expect(response).not.toHaveBodyEquals('404 NOT FOUND');
 });
 ```
 
@@ -1530,10 +1530,10 @@ test('passes when response body match the expected body', async () => {
 });
 
 test('passes when using .not.toHaveBodyMatchObject() with different body', async () => {
-    const response = await axios.get('https://some-api.com');
-    expect(response).not.toHaveBodyMatchObject({
-        name: 'hello',
-    });
+  const response = await axios.get('https://some-api.com');
+  expect(response).not.toHaveBodyMatchObject({
+    name: 'hello',
+  });
 });
 ```