sequelize-middleware/test/patchOne.test.js

/* eslint-disable jest/no-test-callback */
import { createBrand, truncate } from "./utils/common";

import models from "../models";
import Brands from "../rules/Brands";
import Middelware from "../index";

let brand = {};

describe("patchOne", () => {
  beforeAll(done => {
    createBrand((err, item) => {
      if (err) {
        done(err);
      } else {
        brand = item;
        done();
      }
    });
  });

  afterAll(done => {
    truncate(["Brands"], done);
  });

  test("It should return 401.1 if guest tries to update item", async done => {
    const middleware = new Middelware(Brands, models);
    const req = {
      method: "PATCH",
      user: null,
      params: {
        brandId: brand.id
      },
      query: {},
      protocol: "http",
      get: () => {
        return "internal.test/";
      },
      originalUrl: "v1/"
    };

    middleware.patchOne(req, (err, res) => {
      expect(res).toBeUndefined();
      expect(parseFloat(err.errorCode)).toBe(401.1);

      done();
    });
  });

  test("It should return 401.1 if bad role tries to update item", async done => {
    const middleware = new Middelware(Brands, models);
    const req = {
      method: "PATCH",
      user: {
        role: "user"
      },
      params: {
        brandId: brand.id
      },
      query: {},
      protocol: "http",
      get: () => {
        return "internal.test/";
      },
      originalUrl: "v1/"
    };

    middleware.patchOne(req, (err, res) => {
      expect(res).toBeUndefined();
      expect(parseFloat(err.errorCode)).toBe(401.1);

      done();
    });
  });

  test("It should return 406.1 if allowed user tries to patch item with unallowed values", async done => {
    const middleware = new Middelware(Brands, models);
    const req = {
      method: "PATCH",
      user: {
        role: "admin"
      },
      params: {
        brandId: brand.id
      },
      query: {},
      body: {
        created: "test",
        name: "TEST"
      },
      protocol: "http",
      get: () => {
        return "internal.test/";
      },
      originalUrl: "v1/"
    };

    middleware.patchOne(req, (err, res) => {
      expect(res).toBeUndefined();
      expect(parseFloat(err.errorCode)).toBe(406.1);

      done();
    });
  });

  test("It should return updated item if allowed user patch item", async done => {
    const middleware = new Middelware(Brands, models);
    const req = {
      method: "PATCH",
      user: {
        role: "admin"
      },
      params: {
        brandId: brand.id
      },
      query: {},
      body: {
        name: "TEST"
      },
      protocol: "http",
      get: () => {
        return "internal.test/";
      },
      originalUrl: "v1/"
    };

    middleware.patchOne(req, (err, res) => {
      expect(err).toBeNull();
      expect(res.name).toBe("TEST");

      done();
    });
  });

  test("It should return 404.1 if allowed user tries to patch not found item", async done => {
    const middleware = new Middelware(Brands, models);
    const req = {
      method: "PATCH",
      user: {
        role: "admin"
      },
      params: {
        brandId: brand.id + 1
      },
      query: {},
      body: {
        name: "TEST"
      },
      protocol: "http",
      get: () => {
        return "internal.test/";
      },
      originalUrl: "v1/"
    };

    middleware.patchOne(req, (err, res) => {
      expect(res).toBeUndefined();
      expect(parseInt(err.errorCode, 10)).toBe(404);

      done();
    });
  });
});