Added some new tests

test/belongsToMany.test.js

@@ -0,0 +1,286 @@
+/* eslint-disable jest/no-test-callback */
+import uuid from "uuid/v4";
+import { truncate } from "./utils/common";
+
+import models from "../models";
+import Cars from "../rules/Cars";
+import Middelware from "../index";
+
+const { Op } = models.Sequelize;
+
+let colors = [];
+const colorsId = [];
+let car = {};
+
+describe("createOne", () => {
+  beforeAll(done => {
+    models.Colors.findAll({
+      where: {
+        [Op.or]: [
+          {
+            name: "White"
+          },
+          {
+            name: "Miami blue"
+          },
+          {
+            name: "Sunflower yellow"
+          }
+        ]
+      }
+    })
+      .then(items => {
+        colors = items;
+        colorsId.push(items[0].id);
+        colorsId.push(items[1].id);
+
+        done();
+      })
+      .catch(done);
+  });
+
+  afterAll(done => {
+    truncate(["Cars"], done);
+  });
+
+  test("It should return new item after creation", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "POST",
+      user: {
+        role: "admin"
+      },
+      body: {
+        name: uuid(),
+        year: 2004,
+        active: true,
+        colorsId
+      }
+    };
+
+    middleware.createOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.name).toBe(req.body.name);
+      expect(res.year).toBe(2004);
+      expect(res.active).toBe(true);
+
+      car = res;
+
+      done();
+    });
+  });
+
+  test("It should return item with relations", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "POST",
+      user: {
+        role: "admin"
+      },
+      params: {
+        carId: car.id
+      }
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.name).toBe(car.name);
+      expect(res.Colors.length).toBe(2);
+      expect(res.year).toBe(2004);
+      expect(res.Colors[0].id).toBe(colorsId[0]);
+      expect(res.Colors[1].id).toBe(colorsId[1]);
+
+      done();
+    });
+  });
+
+  test("It should return all items ", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "POST",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.data[0].name).toBe(car.name);
+      expect(res.data[0].Colors.length).toBe(2);
+      expect(res.data[0].Colors[0].id).toBe(colorsId[0]);
+      expect(res.data[0].Colors[1].id).toBe(colorsId[1]);
+
+      done();
+    });
+  });
+
+  test("It should return ok when update item", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "PATCH",
+      user: {
+        role: "admin"
+      },
+      params: {
+        carId: car.id
+      },
+      query: {},
+      body: {
+        year: 1998,
+        colorsId: [colors[2].id]
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.patchOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.name).toBe(car.name);
+      expect(res.year).toBe(1998);
+
+      done();
+    });
+  });
+
+  test("It should return updated item", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "PATCH",
+      user: {
+        role: "admin"
+      },
+      params: {
+        carId: car.id
+      },
+      query: {},
+      body: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.name).toBe(car.name);
+      expect(res.year).toBe(1998);
+      expect(res.Colors.length).toBe(3);
+
+      done();
+    });
+  });
+
+  test("It should return empty object after delete", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "DELETE",
+      user: {
+        role: "admin"
+      },
+      params: {
+        carId: car.id
+      },
+      query: {},
+      body: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.deleteOne(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toEqual({});
+
+      models.CarsColors.findAll({
+        where: {
+          CarId: car.id
+        }
+      })
+        .then(carsColors => {
+          expect(carsColors.length).toBe(0);
+
+          models.Cars.findAll({
+            where: {
+              id: car.id
+            }
+          }).then(items => {
+            expect(items.length).toBe(0);
+
+            done();
+          });
+        })
+        .catch(done);
+    });
+  });
+
+  test("It should return empty item when delete item with empty belongsTo collection", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "POST",
+      user: {
+        role: "admin"
+      },
+      body: {
+        name: uuid(),
+        year: 2004,
+        active: true
+      }
+    };
+
+    middleware.createOne(req, (err, newCar) => {
+      expect(err).toBeNull();
+
+      expect(newCar.name).toBe(req.body.name);
+      expect(newCar.year).toBe(2004);
+      expect(newCar.active).toBe(true);
+
+      const reqItem = {
+        method: "PATCH",
+        user: {
+          role: "admin"
+        },
+        params: {
+          carId: newCar.id
+        },
+        query: {},
+        body: {
+          year: 1998
+        },
+        protocol: "http",
+        get: () => {
+          return "internal.test/";
+        },
+        originalUrl: "v1/"
+      };
+
+      middleware.patchOne(reqItem, errPatch => {
+        expect(errPatch).toBeNull();
+
+        reqItem.method = "DELETE";
+
+        middleware.deleteOne(reqItem, errDelete => {
+          expect(errDelete).toBeNull();
+          done();
+        });
+      });
+    });
+  });
+});

test/patchOne.test.js

@@ -0,0 +1,163 @@
+/* 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();
+    });
+  });
+});

test/utils/common.js

@@ -1,5 +1,6 @@
 import uuid from "uuid/v4";
 import models from "../../models";
+import truncateDefault from "./truncate";
 
 const _createCar = (brandId, active, year, done) => {
   models.Cars.create({
@@ -42,47 +43,7 @@ const _createBrands = (total, done) => {
   }
 };
 
-const _truncateCars = (tables, done) => {
-  if (tables.indexOf("Cars") === -1) {
-    done(null);
-    return true;
-  }
-
-  models.Cars.destroy({
-    where: {}
-  })
-    .then(() => done(null))
-    .catch(err => done(err));
-  return true;
-};
-
-const _truncateBrands = (tables, done) => {
-  if (tables.indexOf("Brands") === -1) {
-    done(null);
-    return true;
-  }
-
-  models.Brands.destroy({
-    where: {}
-  })
-    .then(() => done(null))
-    .catch(err => done(err));
-  return true;
-};
-
-const _truncate = (tables, done) => {
-  _truncateCars(tables, errCars => {
-    if (errCars) {
-      done(errCars);
-    } else {
-      _truncateBrands(tables, errBrands => {
-        done(errBrands);
-      });
-    }
-  });
-};
-
 export const createBrand = _createBrand;
 export const createBrands = _createBrands;
 export const createCar = _createCar;
-export const truncate = _truncate;
+export const truncate = truncateDefault;

test/utils/truncate.js

@@ -0,0 +1,45 @@
+import models from "../../models";
+
+const _truncateCars = (tables, done) => {
+  if (tables.indexOf("Cars") === -1) {
+    done(null);
+    return true;
+  }
+
+  models.CarsColors.destroy({
+    where: {}
+  })
+    .then(() => {
+      models.Cars.destroy({
+        where: {}
+      }).then(() => done(null));
+    })
+    .catch(err => done(err));
+  return true;
+};
+
+const _truncateBrands = (tables, done) => {
+  if (tables.indexOf("Brands") === -1) {
+    done(null);
+    return true;
+  }
+
+  models.Brands.destroy({
+    where: {}
+  })
+    .then(() => done(null))
+    .catch(err => done(err));
+  return true;
+};
+
+export default (tables, done) => {
+  _truncateCars(tables, errCars => {
+    if (errCars) {
+      done(errCars);
+    } else {
+      _truncateBrands(tables, errBrands => {
+        done(errBrands);
+      });
+    }
+  });
+};