@pixwel/pixwel-sdk 2.0.0 → 2.1.0

package/test/Model.spec.js

@@ -0,0 +1,328 @@
+import { Pixwel, Model } from "../index";
+import axios from "axios";
+
+let request, post, patch, get, deleteMock;
+
+class AssetType extends Model {
+	constructor(data) {
+		super(data);
+		this._resource = "assettypes";
+		this._constraints = {
+			name: {
+				presence: true
+			}
+		};
+	}
+	static get _resource() {
+		return "assettypes";
+	}
+}
+
+describe("Model", () => {
+	beforeEach(() => {
+		request = jest.fn();
+		post = jest.fn().mockResolvedValue({
+			data: { _id: "a1b2c3", name: "dude", title: "Programmer" }
+		});
+		patch = jest.fn().mockResolvedValue({
+			data: { _id: "a1b2c3", name: "dude", title: "Programmer" }
+		});
+		get = jest.fn();
+		deleteMock = jest.fn();
+		axios.create = jest.fn().mockImplementation(() => {
+			return {
+				request: request,
+				post: post,
+				patch: patch,
+				get: get,
+				delete: deleteMock
+			};
+		});
+	});
+	describe("constructor", () => {
+		it("should assign data passed via params", () => {
+			let data = {
+				name: "dude"
+			};
+			let model = new Model(data);
+			expect(model.name).toEqual("dude");
+		});
+		it("should set up api connection", () => {
+			Pixwel.credentials.token = "a1b2c3";
+			let model = new Model();
+			expect(model._endpoint).toEqual("https://api.pixwel.com/api");
+			expect(axios.create.mock.calls[0][0]).toEqual({
+				baseURL: "https://api.pixwel.com/api",
+				headers: {
+					Authorization: "Basic a1b2c3",
+					Accept: "application/json",
+					"Content-Type": "application/json"
+				}
+			});
+		});
+	});
+	describe("set", () => {
+		it("should merge incoming data into the model", () => {
+			let model = new Model();
+			model.set({ details: { name: "Jeff" } });
+			expect(model.data()).toEqual({
+				_id: undefined,
+				details: { name: "Jeff" }
+			});
+		});
+	});
+	describe("validates", () => {
+		it("should return true if passes all constraints", () => {
+			class Person extends Model {
+				constructor(data) {
+					super(data);
+					this._constraints = {
+						name: {
+							presence: true
+						}
+					};
+				}
+			}
+			let person = new Person({ name: "Jeff" });
+			let isValid = person.validates();
+			expect(isValid).toBe(true);
+		});
+		it("should return false if fails a constraint", () => {
+			class Person extends Model {
+				constructor(data) {
+					super(data);
+					this._constraints = {
+						name: {
+							presence: true
+						}
+					};
+				}
+			}
+			let person = new Person();
+			let isValid = person.validates();
+			expect(isValid).toBe(false);
+		});
+	});
+	describe("errors", () => {
+		it("should returns empty array if all fields pass constraints", () => {
+			let res = new Model({ name: "Jeff" });
+			let isValid = res.validates();
+			expect(isValid).toBe(true);
+			let errors = res.errors();
+			expect(errors).toEqual([]);
+		});
+		it("should returns error array if a field fails a constraint", () => {
+			class Person extends Model {
+				constructor(data) {
+					super(data);
+					this._constraints = {
+						name: {
+							presence: true
+						}
+					};
+				}
+			}
+			let person = new Person();
+			let isValid = person.validates();
+			expect(isValid).toBe(false);
+			let errors = person.errors();
+			expect(errors).toEqual({ name: ["Name can't be blank"] });
+		});
+	});
+	describe("clone", () => {
+		it("should clone the model", () => {
+			let model = new Model({ name: "sup" });
+			let cloned = model.clone();
+			let res = cloned.save();
+			expect(res).toBeTruthy();
+		});
+	});
+	describe("registerCallback", () => {
+		it("register a listener on find with a callback", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: [{ _id: "a1b2c3", name: "dude", title: "Programmer" }]
+			});
+			let callback = jest.fn();
+			Model.registerCallback("find", callback);
+			await Model.find();
+			expect(callback.mock.calls[0][0]).toEqual([
+				{ _id: "a1b2c3", name: "dude", title: "Programmer" }
+			]);
+			done();
+		});
+		it("register a listener on save with a callback", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: [{ _id: "a1b2c3", name: "dude", title: "Programmer" }]
+			});
+			let callback = jest.fn();
+			Model.registerCallback("save", callback);
+			let model = new Model();
+			await model.save();
+			expect(callback.mock.calls[0][0]).toEqual({
+				_id: "a1b2c3",
+				name: "dude",
+				title: "Programmer"
+			});
+			done();
+		});
+	});
+	describe("all", () => {
+		it("should fetch an object collection with a object parameter", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: { _id: "a1b2c3", name: "dude", title: "Programmer" }
+			});
+			let res = await AssetType.all({ verified: true });
+			expect(res).toBeTruthy();
+			expect(get.mock.calls[0][0]).toEqual("assettypes");
+			expect(get.mock.calls[0][1]).toEqual({
+				params: { verified: true }
+			});
+			done();
+		});
+	});
+	describe("find", () => {
+		it("should correctly set Model.resource when extended", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: [{ _id: "a1b2c3", name: "dude", title: "Programmer" }]
+			});
+			let types = await AssetType.find();
+			expect(get.mock.calls).toEqual([["assettypes", { params: {} }]]);
+			done();
+		});
+		it("should fetch a single object with a string parameter", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: { _id: "a1b2c3", name: "dude", title: "Programmer" }
+			});
+			let res = await AssetType.find("a1b2c3");
+			expect(res).toBeTruthy();
+			expect(get.mock.calls[0][0]).toEqual("assettypes/a1b2c3");
+			done();
+		});
+		it("should fetch an object collection with an empty parameter", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: [{ _id: "a1b2c3", name: "dude", title: "Programmer" }]
+			});
+			let res = await AssetType.find();
+			expect(res).toBeTruthy();
+			expect(get.mock.calls[0][0]).toEqual("assettypes");
+			done();
+		});
+		it("should fetch an object collection with a object parameter", async done => {
+			get = jest.fn().mockResolvedValue({
+				data: [{ _id: "a1b2c3", name: "dude", title: "Programmer", verified: true }]
+			});
+			let res = await AssetType.find({ verified: true });
+			expect(res).toBeTruthy();
+			expect(get.mock.calls[0][0]).toEqual("assettypes");
+			expect(get.mock.calls[0][1]).toEqual({
+				params: { verified: true }
+			});
+			done();
+		});
+	});
+	describe("data", () => {
+		it("should return data values for model", () => {
+			let model = new Model({ name: "dude" });
+			model.age = 4;
+			let data = model.data();
+			expect(data).toEqual({ age: 4, name: "dude" });
+		});
+	});
+	describe("save", () => {
+		it("should patch differences on save if id is present", async done => {
+			let assetType = new AssetType({ name: "dude" });
+			await assetType.save();
+			assetType.age = 20;
+			let res = await assetType.save();
+			expect(patch.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes/a1b2c3"
+			);
+			expect(patch.mock.calls[0][1]).toEqual({ age: 20 });
+			expect(res).toBeTruthy();
+			done();
+		});
+		it("should create a new record with object properties", async done => {
+			let assetType = new AssetType({ name: "dude" });
+			let res = await assetType.save();
+			expect(assetType.title).toEqual("Programmer");
+			expect(typeof res).toBe("object");
+			expect(post.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes"
+			);
+			expect(post.mock.calls[0][1]).toEqual({ name: "dude" });
+			done();
+		});
+		it("should update a record with object properties when id is present", async done => {
+			let assetType = new AssetType({ _id: "a1b2c3", name: "dude" });
+			let res = await assetType.save();
+			expect(assetType.title).toEqual("Programmer");
+			expect(typeof res).toBe("object");
+			expect(patch.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes/a1b2c3"
+			);
+			expect(patch.mock.calls[0][1]).toEqual({ _id: "a1b2c3", name: "dude" });
+			done();
+		});
+	});
+	describe("request", () => {
+		it("should make an api request", async done => {
+			request.mockResolvedValue("returnValue");
+			let model = new Model();
+			let res = await model.request({ hi: "dude" });
+			expect(res).toEqual("returnValue");
+			expect(request.mock.calls[0][0]).toEqual({ hi: "dude" });
+			done();
+		});
+	});
+	describe("create", () => {
+		it("should create a resource", async done => {
+			post.mockResolvedValue({ data: { name: "Thor" } });
+			let assetType = new AssetType();
+			let res = await assetType.create({ name: "Thor" });
+			expect(res).toEqual({ name: "Thor" });
+			expect(post.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes"
+			);
+			expect(post.mock.calls[0][1]).toEqual({ name: "Thor" });
+			done();
+		});
+	});
+	describe("update", () => {
+		it("should update a resource", async done => {
+			patch.mockResolvedValue({ data: { _id: 'a1b2c3', name: "Thor" } });
+			let assetType = new AssetType();
+			let res = await assetType.update('a1b2c3', { name: "Thor" });
+			expect(res).toEqual({"_id": "a1b2c3", "name": "Thor"});
+			expect(patch.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes/a1b2c3"
+			);
+			expect(patch.mock.calls[0][1]).toEqual({"name": "Thor"});
+			done();
+		});
+	});
+	describe("read", () => {
+		it("should read a resource using querystring", async done => {
+			get.mockResolvedValue({ data: [{ _id: 'a1b2c3', name: "Thor" }] });
+			let assetType = new AssetType();
+			let res = await assetType.read('a1b2c3' ,{ name: "Thor" });
+			expect(res).toEqual([{ _id: "a1b2c3", name: "Thor" }]);
+			expect(get.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes/a1b2c3"
+			);
+			expect(get.mock.calls[0][1]).toEqual({ name: "Thor" });
+			done();
+		});
+	});
+	describe("delete", () => {
+		it("should delete a resource", async done => {
+			deleteMock.mockResolvedValue({ data: {} });
+			let assetType = new AssetType();
+			let res = await assetType.delete("a1b2c3");
+			expect(res).toEqual({});
+			expect(deleteMock.mock.calls[0][0]).toEqual(
+				"https://api.pixwel.com/api/assettypes/a1b2c3"
+			);
+			done();
+		});
+	});
+});