tests: http statuses type success

Author: helderberto

src/validators/index.js

@@ -8,8 +8,18 @@ export {
 } from './informational/is-switching-protocols';
 
 // 2×× Success
-export { default as isCreated } from './success/is-created';
 export { default as isOk } from './success/is-ok';
+export { default as isCreated } from './success/is-created';
+export { default as isAccepted } from './success/is-accepted';
+export {
+  default as isNonAuthoritativeInformation
+} from './success/is-non-authoritative-information';
+export { default as isNoContent } from './success/is-no-content';
+export { default as isResetContent } from './success/is-reset-content';
+export { default as isPartialContent } from './success/is-partial-content';
+export { default as isMultiStatus } from './success/is-multi-status';
+export { default as isAlreadyReported } from './success/is-already-reported';
+export { default as isImUsed } from './success/is-im-used';
 
 // 3×× Redirection
 export {

src/validators/success/is-accepted.js

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

src/validators/success/is-already-reported.js

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

src/validators/success/is-im-used.js

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

src/validators/success/is-multi-status.js

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

src/validators/success/is-no-content.js

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

src/validators/success/is-non-authoritative-information.js

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

src/validators/success/is-partial-content.js

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

src/validators/success/is-reset-content.js

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

tests/is-continue.test.js

@@ -1,4 +1,4 @@
-import { isUnauthorized } from '../src';
+import { isUnauthorized } from '../../../src';
 
 describe('isMovedPermanently', () => {
   test('it should receive true when pass status 401', () => {

tests/is-created.test.js

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

tests/is-ok.test.js

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

tests/is-processing.test.js

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

tests/is-switching-protocols.test.js

@@ -1,4 +1,4 @@
-import { isMovedPermanently } from '../src';
+import { isMovedPermanently } from '../../../src';
 
 describe('isMovedPermanently', () => {
   test('it should receive true when pass status 301', () => {

tests/is-unauthorized.test.js tests/validators/client-error/is-unauthorized.test.js

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

tests/validators/informational/is-continue.test.js

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

tests/validators/informational/is-processing.test.js

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

tests/validators/informational/is-switching-protocols.test.js

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

tests/is-moved-permanently.test.js tests/validators/redirection/is-moved-permanently.test.js

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

tests/validators/success/is-accepted.test.js

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

tests/validators/success/is-already-reported.test.js

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

tests/validators/success/is-created.test.js

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