From b9b164ab31e0d5c0f394d6a3ab96e75c7aaec541 Mon Sep 17 00:00:00 2001 From: Victor Woeltjen Date: Fri, 21 Nov 2014 17:51:45 -0800 Subject: [PATCH] [Core] Spec for domain objects Spec for DomainObject and DomainObjectProvider; part of ongoing test coverage for transition of platform/core bundle, WTD-573. --- platform/core/bundle.json | 2 +- .../core/src/objects/DomainObjectProvider.js | 5 +- .../test/objects/DomainObjectProviderSpec.js | 59 +++++++++++++++++++ .../core/test/objects/DomainObjectSpec.js | 55 ++++++++++++++++- 4 files changed, 117 insertions(+), 4 deletions(-) diff --git a/platform/core/bundle.json b/platform/core/bundle.json index 17b2e60aae..0bab37034f 100644 --- a/platform/core/bundle.json +++ b/platform/core/bundle.json @@ -8,7 +8,7 @@ "provides": "objectService", "type": "provider", "implementation": "objects/DomainObjectProvider.js", - "depends": [ "modelService", "capabilityService" ] + "depends": [ "modelService", "capabilityService", "$q" ] }, { "provides": "capabilityService", diff --git a/platform/core/src/objects/DomainObjectProvider.js b/platform/core/src/objects/DomainObjectProvider.js index 4ae3f603f1..60a22d27db 100644 --- a/platform/core/src/objects/DomainObjectProvider.js +++ b/platform/core/src/objects/DomainObjectProvider.js @@ -16,9 +16,10 @@ define( * @param {CapabilityService} capabilityService the service * which provides capabilities (dynamic behavior) * for domain objects. + * @param $q Angular's $q, for promise consolidation * @constructor */ - function DomainObjectProvider(modelService, capabilityService) { + function DomainObjectProvider(modelService, capabilityService, $q) { // Given a models object (containing key-value id-model pairs) // create a function that will look up from the capability // service based on id; for handy mapping below. @@ -54,7 +55,7 @@ define( // domain object provider. function getObjects(ids) { return modelService.getModels(ids).then(function (models) { - return Promise.all( + return $q.all( ids.map(capabilityResolver(models)) ).then(function (capabilities) { return assembleResult(ids, models, capabilities); diff --git a/platform/core/test/objects/DomainObjectProviderSpec.js b/platform/core/test/objects/DomainObjectProviderSpec.js index 7ae3d276c4..1294fd26b5 100644 --- a/platform/core/test/objects/DomainObjectProviderSpec.js +++ b/platform/core/test/objects/DomainObjectProviderSpec.js @@ -9,6 +9,65 @@ define( "use strict"; describe("The domain object provider", function () { + var mockModelService, + mockCapabilityService, + mockQ, + provider; + + function mockPromise(value) { + return (value && value.then) ? value : { + then: function (callback) { + return mockPromise(callback(value)); + }, + // Provide a synchronous way to get a value out + // of this phony promise. + testValue: value + }; + } + + function mockAll(mockPromises) { + return mockPromise(mockPromises.map(function (p) { + return mockPromise(p).testValue; + })); + } + + beforeEach(function () { + mockModelService = jasmine.createSpyObj( + "modelService", + [ "getModels" ] + ); + mockCapabilityService = jasmine.createSpyObj( + "capabilityService", + [ "getCapabilities" ] + ); + mockQ = { + when: mockPromise, + all: mockAll + }; + provider = new DomainObjectProvider( + mockModelService, + mockCapabilityService, + mockQ + ); + }); + + it("requests models from the model service", function () { + var ids = [ "a", "b", "c" ]; + mockModelService.getModels.andReturn(mockPromise({})); + provider.getObjects(ids); + expect(mockModelService.getModels).toHaveBeenCalledWith(ids); + }); + + + it("instantiates objects with provided models", function () { + var ids = [ "a", "b", "c"], + model = { someKey: "some value"}, + result; + mockModelService.getModels.andReturn(mockPromise({ a: model })); + result = provider.getObjects(ids).testValue; + expect(result.a.getId()).toEqual("a"); + expect(result.a.getModel()).toEqual(model); + }); }); } diff --git a/platform/core/test/objects/DomainObjectSpec.js b/platform/core/test/objects/DomainObjectSpec.js index 5dc1bdae56..8b99665617 100644 --- a/platform/core/test/objects/DomainObjectSpec.js +++ b/platform/core/test/objects/DomainObjectSpec.js @@ -8,7 +8,60 @@ define( function (DomainObject) { "use strict"; - describe("", function () { + describe("A domain object", function () { + var testId = "test id", + testModel = { someKey: "some value"}, + testCapabilities = { + "static": "some static capability", + "dynamic": function (domainObject) { + return "Dynamically generated for " + + domainObject.getId(); + }, + "invokable": { + invoke: function (arg) { + return "invoked with " + arg; + } + } + }, + domainObject; + + beforeEach(function () { + domainObject = new DomainObject( + testId, + testModel, + testCapabilities + ); + }); + + it("reports its id", function () { + expect(domainObject.getId()).toEqual(testId); + }); + + it("reports its model", function () { + expect(domainObject.getModel()).toEqual(testModel); + }); + + it("reports static capabilities", function () { + expect(domainObject.getCapability("static")) + .toEqual("some static capability"); + }); + + it("instantiates dynamic capabilities", function () { + expect(domainObject.getCapability("dynamic")) + .toEqual("Dynamically generated for test id"); + }); + + it("allows for checking for the presence of capabilities", function () { + Object.keys(testCapabilities).forEach(function (capability) { + expect(domainObject.hasCapability(capability)).toBeTruthy(); + }); + expect(domainObject.hasCapability("somethingElse")).toBeFalsy(); + }); + + it("allows for shorthand capability invocation", function () { + expect(domainObject.useCapability("invokable", "a specific value")) + .toEqual("invoked with a specific value"); + }); }); }