feat: validators type server error

Author: helderberto

src/validators/index.js

@@ -43,3 +43,29 @@ export {
 export { default as isUnauthorized } from './client-error/is-unauthorized';
 
 // 5×× Server Error
+export { default as isBadGateway } from './server-error/is-bad-gateway';
+export { default as isGatewayTimeout } from './server-error/is-gateway-timeout';
+export {
+  default as isHttpVersionNotSupported
+} from './server-error/is-http-version-not-supported';
+export {
+  default as isInsufficientStorage
+} from './server-error/is-insufficient-storage';
+export {
+  default as isInternalServerError
+} from './server-error/is-internal-server-error';
+export { default as isLoopDetected } from './server-error/is-loop-detected';
+export {
+  default as isNetworkAuthenticationRequired
+} from './server-error/is-network-authentication-required';
+export {
+  default as isNetworkConnectTimeoutError
+} from './server-error/is-network-connect-timeout-error';
+export { default as isNotExtended } from './server-error/is-not-extended';
+export { default as isNotImplemented } from './server-error/is-not-implemented';
+export {
+  default as isServiceUnavailable
+} from './server-error/is-service-unavailable';
+export {
+  default as isVariantAlsoNegotiates
+} from './server-error/is-variant-also-negotiates';

src/validators/server-error/is-bad-gateway.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isBadGateway
+ * @description
+ * Validate HTTP Status code 502 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 502
+ */
+function isBadGateway(statusCode) {
+  return validateHttpStatus(statusCode, 502);
+}
+
+export default isBadGateway;

src/validators/server-error/is-gateway-timeout.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isGatewayTimeout
+ * @description
+ * Validate HTTP Status code 504 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 504
+ */
+function isGatewayTimeout(statusCode) {
+  return validateHttpStatus(statusCode, 504);
+}
+
+export default isGatewayTimeout;

src/validators/server-error/is-http-version-not-supported.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isHttpVersionNotSupported
+ * @description
+ * Validate HTTP Status code 505 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 504
+ */
+function isHttpVersionNotSupported(statusCode) {
+  return validateHttpStatus(statusCode, 505);
+}
+
+export default isHttpVersionNotSupported;

src/validators/server-error/is-insufficient-storage.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isInsufficientStorage
+ * @description
+ * Validate HTTP Status code 507 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 507
+ */
+function isInsufficientStorage(statusCode) {
+  return validateHttpStatus(statusCode, 507);
+}
+
+export default isInsufficientStorage;

src/validators/server-error/is-internal-server-error.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isInternalServerError
+ * @description
+ * Validate HTTP Status code 500 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 500
+ */
+function isInternalServerError(statusCode) {
+  return validateHttpStatus(statusCode, 500);
+}
+
+export default isInternalServerError;

src/validators/server-error/is-loop-detected.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isLoopDetected
+ * @description
+ * Validate HTTP Status code 508 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 508
+ */
+function isLoopDetected(statusCode) {
+  return validateHttpStatus(statusCode, 508);
+}
+
+export default isLoopDetected;

src/validators/server-error/is-network-authentication-required.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isNetworkAuthenticationRequired
+ * @description
+ * Validate HTTP Status code 511 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 511
+ */
+function isNetworkAuthenticationRequired(statusCode) {
+  return validateHttpStatus(statusCode, 511);
+}
+
+export default isNetworkAuthenticationRequired;

src/validators/server-error/is-network-connect-timeout-error.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isNetworkConnectTimeoutError
+ * @description
+ * Validate HTTP Status code 599 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 599
+ */
+function isNetworkConnectTimeoutError(statusCode) {
+  return validateHttpStatus(statusCode, 599);
+}
+
+export default isNetworkConnectTimeoutError;

src/validators/server-error/is-not-extended.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isNotExtended
+ * @description
+ * Validate HTTP Status code 510 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 510
+ */
+function isNotExtended(statusCode) {
+  return validateHttpStatus(statusCode, 510);
+}
+
+export default isNotExtended;

src/validators/server-error/is-not-implemented.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isNotImplemented
+ * @description
+ * Validate HTTP Status code 501 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 501
+ */
+function isNotImplemented(statusCode) {
+  return validateHttpStatus(statusCode, 501);
+}
+
+export default isNotImplemented;

src/validators/server-error/is-service-unavailable.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isServiceUnavailable
+ * @description
+ * Validate HTTP Status code 503 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 503
+ */
+function isServiceUnavailable(statusCode) {
+  return validateHttpStatus(statusCode, 503);
+}
+
+export default isServiceUnavailable;

src/validators/server-error/is-variant-also-negotiates.js

@@ -0,0 +1,16 @@
+import validateHttpStatus from '../validate-http-status';
+
+/**
+ * @module isVariantAlsoNegotiates
+ * @description
+ * Validate HTTP Status code 506 type SERVER ERROR
+ *
+ * @param {Integer} statusCode - The HTTP Status code
+ * @return {Boolean}
+ * @throws {HTTPStatusError}  When the statusCode is different then 506
+ */
+function isVariantAlsoNegotiates(statusCode) {
+  return validateHttpStatus(statusCode, 506);
+}
+
+export default isVariantAlsoNegotiates;

tests/validators/server-error/is-Internal-server-error.test.js

@@ -0,0 +1,14 @@
+import { isInternalServerError } from '../../../src';
+
+describe('Validators: isInternalServerError (type server error)', () => {
+  const STATUS_EXPECTED = 500;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isInternalServerError(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isInternalServerError(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-bad-gateway.test.js

@@ -0,0 +1,14 @@
+import { isBadGateway } from '../../../src';
+
+describe('Validators: isBadGateway (type server error)', () => {
+  const STATUS_EXPECTED = 502;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isBadGateway(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isBadGateway(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-gateway-timeout.test.js

@@ -0,0 +1,14 @@
+import { isGatewayTimeout } from '../../../src';
+
+describe('Validators: isGatewayTimeout (type server error)', () => {
+  const STATUS_EXPECTED = 504;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isGatewayTimeout(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isGatewayTimeout(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-http-version-not-supported.test.js

@@ -0,0 +1,14 @@
+import { isHttpVersionNotSupported } from '../../../src';
+
+describe('Validators: isBadGateway (type server error)', () => {
+  const STATUS_EXPECTED = 505;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isHttpVersionNotSupported(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isHttpVersionNotSupported(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-insufficient-storage.test.js

@@ -0,0 +1,14 @@
+import { isInsufficientStorage } from '../../../src';
+
+describe('Validators: isInsufficientStorage (type server error)', () => {
+  const STATUS_EXPECTED = 507;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isInsufficientStorage(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isInsufficientStorage(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-loop-detected.test.js

@@ -0,0 +1,14 @@
+import { isLoopDetected } from '../../../src';
+
+describe('Validators: isLoopDetected (type server error)', () => {
+  const STATUS_EXPECTED = 508;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isLoopDetected(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isLoopDetected(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-network-authentication-required.test.js

@@ -0,0 +1,14 @@
+import { isNetworkAuthenticationRequired } from '../../../src';
+
+describe('Validators: isNetworkAuthenticationRequired (type server error)', () => {
+  const STATUS_EXPECTED = 511;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isNetworkAuthenticationRequired(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isNetworkAuthenticationRequired(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-network-connect-timeout-error.test.js

@@ -0,0 +1,14 @@
+import { isNetworkConnectTimeoutError } from '../../../src';
+
+describe('Validators: isNetworkConnectTimeoutError (type server error)', () => {
+  const STATUS_EXPECTED = 599;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isNetworkConnectTimeoutError(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isNetworkConnectTimeoutError(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-not-extended.test.js

@@ -0,0 +1,14 @@
+import { isNotExtended } from '../../../src';
+
+describe('Validators: isNotExtended (type server error)', () => {
+  const STATUS_EXPECTED = 510;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isNotExtended(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isNotExtended(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-not-implemented.test.js

@@ -0,0 +1,14 @@
+import { isNotImplemented } from '../../../src';
+
+describe('Validators: isNotImplemented (type server error)', () => {
+  const STATUS_EXPECTED = 501;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isNotImplemented(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isNotImplemented(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});

tests/validators/server-error/is-service-unavailable.test.js

@@ -0,0 +1,14 @@
+import { isServiceUnavailable } from '../../../src';
+
+describe('Validators: isServiceUnavailable (type server error)', () => {
+  const STATUS_EXPECTED = 503;
+
+  test(`it should receive true when pass status ${STATUS_EXPECTED}`, () => {
+    expect(isServiceUnavailable(STATUS_EXPECTED)).toBeTruthy();
+  });
+
+  test(`it should throw Error when pass status different than ${STATUS_EXPECTED}`, () => {
+    const received = isServiceUnavailable(300);
+    expect(received.message).toBe(`Expected a ${STATUS_EXPECTED} response.`);
+  });
+});