From c432a4eb1e2ca4b0a512421a75b1183ec78c9f97 Mon Sep 17 00:00:00 2001 From: Victor Woeltjen Date: Tue, 25 Nov 2014 10:51:23 -0800 Subject: [PATCH] [Common UI] Complete specs for edit mode Add specs for remaining capabilities and capability wrappers employed by Edit mode. Completes coverage for bundle platform/commonUI/edit, which is being transitioned along with other commonUI bundles in WTD-574. --- .../EditableContextCapabilitySpec.js | 75 +++++++++++++ .../EditablePersistenceCapabilitySpec.js | 42 ++++++++ .../test/capabilities/EditorCapabilitySpec.js | 101 +++++++++++++++++- 3 files changed, 215 insertions(+), 3 deletions(-) diff --git a/platform/commonUI/edit/test/capabilities/EditableContextCapabilitySpec.js b/platform/commonUI/edit/test/capabilities/EditableContextCapabilitySpec.js index e69de29bb2..d79e9e5029 100644 --- a/platform/commonUI/edit/test/capabilities/EditableContextCapabilitySpec.js +++ b/platform/commonUI/edit/test/capabilities/EditableContextCapabilitySpec.js @@ -0,0 +1,75 @@ +/*global define,describe,it,expect,beforeEach,jasmine*/ + +define( + ["../../src/capabilities/EditableContextCapability"], + function (EditableContextCapability) { + "use strict"; + + describe("An editable context capability", function () { + var mockContext, + mockEditableObject, + mockDomainObject, + mockTestObject, + someValue, + factory, + capability; + + beforeEach(function () { + // EditableContextCapability should watch ALL + // methods for domain objects, so give it an + // arbitrary interface to wrap. + mockContext = jasmine.createSpyObj( + "context", + [ + "getSomething", + "getDomainObject", + "getDomainObjectArray" + ] + ); + mockTestObject = jasmine.createSpyObj( + "domainObject", + [ "getId", "getModel", "getCapability" ] + ); + factory = { + getEditableObject: function (v) { + return { + isFromTestFactory: true, + calledWith: v + }; + } + }; + + someValue = { x: 42 }; + + mockContext.getSomething.andReturn(someValue); + mockContext.getDomainObject.andReturn(mockTestObject); + mockContext.getDomainObjectArray.andReturn([mockTestObject]); + + capability = new EditableContextCapability( + mockContext, + mockEditableObject, + mockDomainObject, + factory + ); + + }); + + it("wraps retrieved domain objects", function () { + var object = capability.getDomainObject(); + expect(object.isFromTestFactory).toBe(true); + expect(object.calledWith).toEqual(mockTestObject); + }); + + it("wraps retrieved domain object arrays", function () { + var object = capability.getDomainObjectArray()[0]; + expect(object.isFromTestFactory).toBe(true); + expect(object.calledWith).toEqual(mockTestObject); + }); + + it("does not wrap non-domain-objects", function () { + expect(capability.getSomething()).toEqual(someValue); + }); + + }); + } +); \ No newline at end of file diff --git a/platform/commonUI/edit/test/capabilities/EditablePersistenceCapabilitySpec.js b/platform/commonUI/edit/test/capabilities/EditablePersistenceCapabilitySpec.js index 1912b31379..327c49bdc1 100644 --- a/platform/commonUI/edit/test/capabilities/EditablePersistenceCapabilitySpec.js +++ b/platform/commonUI/edit/test/capabilities/EditablePersistenceCapabilitySpec.js @@ -6,6 +6,48 @@ define( "use strict"; describe("An editable persistence capability", function () { + var mockPersistence, + mockEditableObject, + mockDomainObject, + mockCache, + capability; + + beforeEach(function () { + mockPersistence = jasmine.createSpyObj( + "persistence", + [ "persist" ] + ); + mockEditableObject = jasmine.createSpyObj( + "editableObject", + [ "getId", "getModel", "getCapability" ] + ); + mockDomainObject = jasmine.createSpyObj( + "editableObject", + [ "getId", "getModel", "getCapability" ] + ); + mockCache = jasmine.createSpyObj( + "cache", + [ "markDirty" ] + ); + + capability = new EditablePersistenceCapability( + mockPersistence, + mockEditableObject, + mockDomainObject, + mockCache + ); + }); + + it("marks objects as dirty (in the cache) upon persist", function () { + capability.persist(); + expect(mockCache.markDirty) + .toHaveBeenCalledWith(mockEditableObject); + }); + + it("does not invoke the underlying persistence capability", function () { + capability.persist(); + expect(mockPersistence.persist).not.toHaveBeenCalled(); + }); }); } diff --git a/platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js b/platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js index 82137b4ab2..041f5c6734 100644 --- a/platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js +++ b/platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js @@ -1,11 +1,106 @@ -/*global define,describe,it,expect,beforeEach,jasmine*/ +/*global define,describe,it,expect,beforeEach,waitsFor,runs,jasmine*/ define( - ["../../src/capabilities/EditableContextCapability"], - function (EditableContextCapability) { + ["../../src/capabilities/EditorCapability"], + function (EditorCapability) { "use strict"; describe("An editable context capability", function () { + var mockPersistence, + mockEditableObject, + mockDomainObject, + mockCache, + mockCallback, + model, + capability; + + beforeEach(function () { + mockPersistence = jasmine.createSpyObj( + "persistence", + [ "persist" ] + ); + mockEditableObject = { + getModel: function () { return model; } + }; + mockDomainObject = jasmine.createSpyObj( + "domainObject", + [ "getId", "getModel", "getCapability", "useCapability" ] + ); + mockCache = jasmine.createSpyObj( + "cache", + [ "saveAll", "markClean" ] + ); + mockCallback = jasmine.createSpy("callback"); + + model = { someKey: "some value", x: 42 }; + + capability = new EditorCapability( + mockPersistence, + mockEditableObject, + mockDomainObject, + mockCache + ); + }); + + it("mutates the real domain object on save", function () { + capability.save().then(mockCallback); + + // Wait for promise to resolve + waitsFor(function () { + return mockCallback.calls.length > 0; + }, 250); + + runs(function () { + expect(mockDomainObject.useCapability) + .toHaveBeenCalledWith("mutation", jasmine.any(Function)); + // We should get the model from the editable object back + expect( + mockDomainObject.useCapability.mostRecentCall.args[1]() + ).toEqual(model); + }); + }); + + it("marks the saved object as clean in the editing cache", function () { + capability.save().then(mockCallback); + + // Wait for promise to resolve + waitsFor(function () { + return mockCallback.calls.length > 0; + }, 250); + + runs(function () { + expect(mockCache.markClean).toHaveBeenCalledWith(mockEditableObject); + }); + }); + + it("tells the cache to save others", function () { + capability.save().then(mockCallback); + + // Wait for promise to resolve + waitsFor(function () { + return mockCallback.calls.length > 0; + }, 250); + + runs(function () { + expect(mockCache.saveAll).toHaveBeenCalled(); + }); + }); + + it("has no interactions on cancel", function () { + capability.cancel().then(mockCallback); + + // Wait for promise to resolve + waitsFor(function () { + return mockCallback.calls.length > 0; + }, 250); + + runs(function () { + expect(mockDomainObject.useCapability).not.toHaveBeenCalled(); + expect(mockCache.markClean).not.toHaveBeenCalled(); + expect(mockCache.saveAll).not.toHaveBeenCalled(); + }); + }); + }); }