Added some tests (createOne and getAll)

test/createOne.test.js

@@ -0,0 +1,177 @@
+/* eslint-disable jest/no-test-callback */
+import uuid from "uuid/v4";
+import { truncate } from "./utils/common";
+
+import models from "../models";
+import Brands from "../rules/Brands";
+import Cars from "../rules/Cars";
+import Middelware from "../index";
+
+let createdBrand = null;
+
+describe("createOne", () => {
+  afterAll(done => {
+    truncate(["Brands", "Cars"], done);
+  });
+
+  test("It should return a 401 when guest tries to create new item", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "POST",
+      user: null,
+      body: {
+        name: uuid()
+      }
+    };
+
+    middleware.createOne(req, (err, res) => {
+      expect(res).toBeUndefined();
+      expect(parseFloat(err.errorCode)).toBe(401.1);
+
+      done();
+    });
+  });
+
+  test("It should return a 401 when unauthorized role tries to create new item", async done => {
+    const middleware = new Middelware(Brands, models);
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "user"
+        },
+        body: {
+          name: uuid()
+        }
+      },
+      (err, res) => {
+        expect(res).toBeUndefined();
+        expect(parseFloat(err.errorCode)).toBe(401.1);
+
+        done();
+      }
+    );
+  });
+
+  test("It should return a 406 when authorized role tries to create new item with missing required values", async done => {
+    const middleware = new Middelware(Brands, models);
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "admin"
+        },
+        body: {}
+      },
+      (err, res) => {
+        expect(res).toBeUndefined();
+        expect(parseFloat(err.errorCode)).toBe(406.1);
+
+        done();
+      }
+    );
+  });
+
+  test("It should return new item when authorized role create new item", async done => {
+    const middleware = new Middelware(Brands, models);
+    const name = uuid();
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "admin"
+        },
+        body: {
+          name
+        }
+      },
+      (err, res) => {
+        expect(err).toBeNull();
+        expect(res).toHaveProperty("id");
+        expect(res).toHaveProperty("created");
+        expect(res).toHaveProperty("updated");
+        expect(res).not.toHaveProperty("createdAt");
+        expect(res).not.toHaveProperty("updatedAt");
+        expect(res.name).toBe(name);
+
+        createdBrand = res;
+
+        done();
+      }
+    );
+  });
+
+  test("It should return errorCode 409.1 when authorized role tries to create new item with same unique field", async done => {
+    const middleware = new Middelware(Brands, models);
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "admin"
+        },
+        body: {
+          name: createdBrand.name
+        }
+      },
+      (err, res) => {
+        expect(res).toBeUndefined();
+        expect(parseFloat(err.errorCode)).toBe(409.1);
+
+        done();
+      }
+    );
+  });
+
+  test("It should return errorCode 406.2 when authorized role tries to create new item with bad foreign id", async done => {
+    const middleware = new Middelware(Cars, models);
+    const name = uuid();
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "admin"
+        },
+        body: {
+          name,
+          year: 2004,
+          brandId: createdBrand.id + 2
+        }
+      },
+      (err, res) => {
+        expect(res).toBeUndefined();
+        expect(parseFloat(err.errorCode)).toBe(406.2);
+
+        done();
+      }
+    );
+  });
+
+  test("It should return errorCode 500 when authorized role tries to create new item with too long value", async done => {
+    const middleware = new Middelware(Cars, models);
+
+    middleware.createOne(
+      {
+        method: "POST",
+        user: {
+          role: "admin"
+        },
+        body: {
+          name:
+            "ThohWaigohhieHogahthoxohpheeDah0geetai0cieNgu1The2foQueeloochoH9eulizieshuf1nivohkied8jei5oph2Lajem6ohviijai6booTh8ienaic9eipheixa4ki1iek2pheihe7een7nei7epahngaerieghoe3ahbeil3yied0ievee1moh8jeeN5quoh6uiph6HaeZ0Eiyohshafohniewaer7gaegiefi5eiquiequoow5ohtheiw6ZeihieMoM8Ejoh7leiNeavi7uapheiwoophitoi3queiBeVeip5too8cah9Ohpaetaogahw1tei0eibuyaef3aht8aighuma6ahK4huP4cew6ohd0aiSh2umeeng7Hizahtoo6xoocePhu4ahtheex3jaijooph9iexaiqu3Nu0Ebeich6iTe",
+          year: 2004
+        }
+      },
+      (err, res) => {
+        expect(res).toBeUndefined();
+        expect(parseFloat(err.errorCode)).toBe(500.0);
+
+        done();
+      }
+    );
+  });
+});

test/getAll.complex.test.js

@@ -0,0 +1,436 @@
+/* eslint-disable jest/no-test-callback */
+import { createBrands, createBrand, createCar, truncate } from "./utils/common";
+
+import models from "../models";
+import Cars from "../rules/Cars";
+import Brands from "../rules/Brands";
+import Middelware from "../index";
+
+const createdCars = [];
+
+describe("getAll (with inclusions)", () => {
+  beforeAll(done => {
+    createBrands(6, err => {
+      if (err) {
+        done(err);
+      } else {
+        createBrand((errBrand, createdBrand) => {
+          if (errBrand) {
+            done(errBrand);
+          } else {
+            createCar(createdBrand.id, true, 2004, (errCar, car) => {
+              if (errCar) {
+                done(errCar);
+              }
+              createdCars.push(car);
+              createCar(createdBrand.id, false, 2004, (errCar2, car2) => {
+                if (errCar2) {
+                  done(errCar2);
+                }
+                createdCars.push(car2);
+                createCar(createdBrand.id, true, 2003, (errCar3, car3) => {
+                  if (errCar3) {
+                    done(errCar3);
+                  }
+                  createdCars.push(car3);
+                  createCar(createdBrand.id, true, 1998, (errCar4, car4) => {
+                    if (errCar4) {
+                      done(errCar4);
+                    }
+                    createdCars.push(car4);
+                    createCar(createdBrand.id, false, 1998, (errCar5, car5) => {
+                      if (errCar5) {
+                        done(errCar5);
+                      }
+                      createdCars.push(car5);
+                      createBrands(2, errLastBrand => {
+                        if (errLastBrand) {
+                          done(errLastBrand);
+                        } else {
+                          models.Cars.create({
+                            name: "la renault fuego",
+                            year: 1980,
+                            active: false
+                          })
+                            .then(() => {
+                              done();
+                            })
+                            .catch(done);
+                        }
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          }
+        });
+      }
+    });
+  });
+  afterAll(done => {
+    truncate(["Brands", "Cars"], done);
+  });
+
+  test("It should return all items when allowed role call getAll without filters (except inactive)", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {},
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(3);
+      expect(res.total).toBe(3);
+      expect(res.maxPage).toBe(1);
+
+      expect(res.paging.first).toBeUndefined();
+      expect(res.paging.prev).toBeUndefined();
+      expect(res.paging.next).toBeUndefined();
+      expect(res.paging.last).toBeUndefined();
+
+      done();
+    });
+  });
+
+  test("It should return all items when allowed role call getAll without filters", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(6);
+      expect(res.total).toBe(6);
+      expect(res.maxPage).toBe(1);
+
+      expect(res.paging.first).toBeUndefined();
+      expect(res.paging.prev).toBeUndefined();
+      expect(res.paging.next).toBeUndefined();
+      expect(res.paging.last).toBeUndefined();
+
+      done();
+    });
+  });
+
+  test("It should return 2 items when set complex filters", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        "year.lte": 2005,
+        "year.gte": 2004
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(2);
+      expect(res.total).toBe(2);
+      expect(res.maxPage).toBe(1);
+
+      done();
+    });
+  });
+
+  test("It should return 1 item when set complex filters", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {},
+      query: {
+        "year.lte": 2005,
+        "year.gte": 2004
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(1);
+      expect(res.total).toBe(1);
+      expect(res.maxPage).toBe(1);
+
+      done();
+    });
+  });
+
+  test("It should return 1 item when get all brands", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(9);
+      expect(res.total).toBe(9);
+      expect(res.maxPage).toBe(1);
+
+      expect(res.data[6].Cars.length).toBe(5);
+
+      done();
+    });
+  });
+
+  test("It should return 1 item when get all brands (without cars)", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(9);
+      expect(res.total).toBe(9);
+      expect(res.maxPage).toBe(1);
+
+      expect(res.data[6].Cars).not.toHaveProperty("Cars");
+
+      done();
+    });
+  });
+
+  test("It should return 3 items when admin send weirdfilter", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc",
+        weirdfilter: "letsgo"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(3);
+      expect(res.total).toBe(3);
+      expect(res.maxPage).toBe(1);
+
+      done();
+    });
+  });
+
+  test("It should return errorCode 406.1 when trying to send unallowed filter", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc",
+        id: 65
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(parseFloat(err.errorCode)).toBe(406.1);
+      expect(res).toBeUndefined();
+      done();
+    });
+  });
+
+  test("It should return one item when trying to get item with name contains 'renault'", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc",
+        "name.lk": "renault"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res.data.length).toBe(1);
+      expect(res.total).toBe(1);
+      expect(res.maxPage).toBe(1);
+
+      done();
+    });
+  });
+
+  test("It should return one item when trying to get item filtered by name", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc",
+        name: "la renault fuego"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res.data.length).toBe(1);
+      expect(res.total).toBe(1);
+      expect(res.maxPage).toBe(1);
+
+      done();
+    });
+  });
+
+  test("It should return empty data when trying to get item filtered by name", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {
+        sort: "id",
+        order: "asc",
+        name: "Clio"
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeUndefined();
+      expect(res).toBeUndefined();
+
+      done();
+    });
+  });
+});

test/getAll.test.js

@@ -0,0 +1,142 @@
+/* eslint-disable jest/no-test-callback */
+import { createBrands, truncate } from "./utils/common";
+
+import models from "../models";
+import Brands from "../rules/Brands";
+import Cars from "../rules/Cars";
+import Middelware from "../index";
+
+describe("getAll", () => {
+  beforeAll(done => {
+    createBrands(40, done);
+  });
+  afterAll(done => {
+    truncate(["Brands", "Cars"], done);
+  });
+
+  test("It should return a 401 when guest tries to get all item", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: null,
+      params: {},
+      query: {}
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(res).toBeUndefined();
+      expect(parseFloat(err.errorCode)).toBe(401.1);
+
+      done();
+    });
+  });
+
+  test("It should return a empty result allowed role get items from empty collection", async done => {
+    const middleware = new Middelware(Cars, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {},
+      query: {}
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeUndefined();
+      expect(res).toBeUndefined();
+
+      done();
+    });
+  });
+
+  test("It should return all items when allowed role call getAll without filters", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {},
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(40);
+      expect(res.total).toBe(40);
+      expect(res.maxPage).toBe(1);
+
+      expect(res.paging.first).toBeUndefined();
+      expect(res.paging.prev).toBeUndefined();
+      expect(res.paging.next).toBeUndefined();
+      expect(res.paging.last).toBeUndefined();
+
+      done();
+    });
+  });
+
+  test("It should return 5 items when allowed role call getAll with limit filter", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {},
+      query: {
+        limit: 5,
+        page: 3
+      },
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/?page=3&limit=5"
+    };
+
+    middleware.getAll(req, (err, res) => {
+      expect(err).toBeNull();
+      expect(res).toHaveProperty("data");
+      expect(res).toHaveProperty("paging");
+      expect(res).toHaveProperty("total");
+      expect(res).toHaveProperty("maxPage");
+
+      expect(res.data.length).toBe(5);
+      expect(res.total).toBe(40);
+      expect(res.maxPage).toBe(8);
+
+      expect(res.data[0]).toHaveProperty("id");
+      expect(res.data[0]).toHaveProperty("name");
+      expect(res.data[0]).not.toHaveProperty("createdAt");
+      expect(res.data[0]).not.toHaveProperty("created");
+      expect(res.data[0]).not.toHaveProperty("updatedAt");
+      expect(res.data[0]).not.toHaveProperty("updated");
+
+      expect(res.paging.first.href).toBe(
+        "http://internal.test/v1/?page=1&limit=5"
+      );
+      expect(res.paging.prev.href).toBe(
+        "http://internal.test/v1/?page=2&limit=5"
+      );
+      expect(res.paging.next.href).toBe(
+        "http://internal.test/v1/?page=4&limit=5"
+      );
+      expect(res.paging.last.href).toBe(
+        "http://internal.test/v1/?page=8&limit=5"
+      );
+
+      done();
+    });
+  });
+});

test/getOne.test.js

@@ -0,0 +1,166 @@
+/* eslint-disable jest/no-test-callback */
+import { createBrands, createCar, truncate } from "./utils/common";
+
+import models from "../models";
+import Brands from "../rules/Brands";
+import Middelware from "../index";
+
+const createdCars = [];
+let createdBrand = {};
+
+describe("getOne", () => {
+  beforeAll(done => {
+    createBrands(4, (err, res) => {
+      if (err) {
+        done(err);
+      } else {
+        // eslint-disable-next-line prefer-destructuring
+        createdBrand = res[1];
+        createCar(createdBrand.id, true, 2004, (errCar, car) => {
+          if (errCar) {
+            done(errCar);
+          }
+          createdCars.push(car);
+          createCar(createdBrand.id, false, 2004, (errCar2, car2) => {
+            if (errCar2) {
+              done(errCar2);
+            }
+            createdCars.push(car2);
+            createCar(createdBrand.id, true, 2003, (errCar3, car3) => {
+              if (errCar3) {
+                done(errCar3);
+              }
+              createdCars.push(car3);
+              createCar(createdBrand.id, true, 1998, (errCar4, car4) => {
+                if (errCar4) {
+                  done(errCar4);
+                }
+                createdCars.push(car4);
+                done();
+              });
+            });
+          });
+        });
+      }
+    });
+  });
+  afterAll(done => {
+    truncate(["Brands", "Cars"], done);
+  });
+
+  test("It should return one item with missing part", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "user"
+      },
+      params: {
+        brandId: createdBrand.id
+      },
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.id).toBe(createdBrand.id);
+      expect(res.name).toBe(createdBrand.name);
+      expect(res).not.toHaveProperty("Cars");
+
+      done();
+    });
+  });
+
+  test("It should return one item with all part", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {
+        brandId: createdBrand.id
+      },
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(err).toBeNull();
+
+      expect(res.id).toBe(createdBrand.id);
+      expect(res.name).toBe(createdBrand.name);
+      expect(res).toHaveProperty("Cars");
+      expect(res.Cars.length).toBe(4);
+      expect(res.Cars[0]).toHaveProperty("id");
+      expect(res.Cars[0]).toHaveProperty("name");
+      expect(res.Cars[0]).toHaveProperty("year");
+      expect(res.Cars[0]).toHaveProperty("created");
+      expect(res.Cars[0]).toHaveProperty("updated");
+      expect(res.Cars[0]).not.toHaveProperty("createdAt");
+      expect(res.Cars[0]).not.toHaveProperty("updatedAt");
+
+      done();
+    });
+  });
+
+  test("It should return errorCode 406.1 when missing itemId", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {},
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(parseFloat(err.errorCode)).toBe(406.1);
+      expect(res).toBeUndefined();
+
+      done();
+    });
+  });
+
+  test("It should return empty result when item not found", async done => {
+    const middleware = new Middelware(Brands, models);
+    const req = {
+      method: "GET",
+      user: {
+        role: "admin"
+      },
+      params: {
+        brandId: createdBrand.id + 666
+      },
+      query: {},
+      protocol: "http",
+      get: () => {
+        return "internal.test/";
+      },
+      originalUrl: "v1/"
+    };
+
+    middleware.getOne(req, (err, res) => {
+      expect(parseFloat(err.errorCode)).toBe(404.0);
+      expect(res).toBeUndefined();
+
+      done();
+    });
+  });
+});

test/utils/common.js

@@ -0,0 +1,88 @@
+import uuid from "uuid/v4";
+import models from "../../models";
+
+const _createCar = (brandId, active, year, done) => {
+  models.Cars.create({
+    name: uuid(),
+    year,
+    active,
+    brandId
+  })
+    .then(item => {
+      done(null, item);
+    })
+    .catch(done);
+};
+
+const _createBrand = done => {
+  models.Brands.create({
+    name: uuid()
+  })
+    .then(item => {
+      done(null, item);
+    })
+    .catch(done);
+};
+
+const _createBrands = (total, done) => {
+  const created = [];
+  const next = () => {
+    if (total === created.length) {
+      done(null, created);
+    }
+  };
+
+  for (let i = 0; i < total; i += 1) {
+    _createBrand((err, res) => {
+      if (!err) {
+        created.push(res);
+        next();
+      }
+    });
+  }
+};
+
+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;

test/utils/setup.js

@@ -0,0 +1,5 @@
+jest.setTimeout(3000);
+
+afterAll(done => {
+  done();
+});