From e18b4f234fc7f05bb7563918f1d70a5783261534 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Fri, 21 Nov 2014 16:06:50 -0800
Subject: [PATCH] [Core] Add spec for CompositionCapability

Add spec for CompositionCapability; ongoing improvement of
test coverage for WTD-573.
---
 .../src/capabilities/CompositionCapability.js |  2 +-
 .../capabilities/CompositionCapabilitySpec.js | 80 +++++++++++++++++++
 2 files changed, 81 insertions(+), 1 deletion(-)

diff --git a/platform/core/src/capabilities/CompositionCapability.js b/platform/core/src/capabilities/CompositionCapability.js
index 2b8f0609dc..7cfa2b6aaa 100644
--- a/platform/core/src/capabilities/CompositionCapability.js
+++ b/platform/core/src/capabilities/CompositionCapability.js
@@ -1,4 +1,4 @@
-/*global define,Promise*/
+/*global define*/
 
 /**
  * Module defining CompositionCapability. Created by vwoeltje on 11/7/14.
diff --git a/platform/core/test/capabilities/CompositionCapabilitySpec.js b/platform/core/test/capabilities/CompositionCapabilitySpec.js
index bc8bc414c8..131f87ddb0 100644
--- a/platform/core/test/capabilities/CompositionCapabilitySpec.js
+++ b/platform/core/test/capabilities/CompositionCapabilitySpec.js
@@ -8,7 +8,87 @@ define(
     function (CompositionCapability) {
         "use strict";
 
+        var DOMAIN_OBJECT_METHODS = [
+            "getId",
+            "getModel",
+            "getCapability",
+            "hasCapability",
+            "useCapability"
+        ];
+
         describe("The composition capability", function () {
+            var mockDomainObject,
+                mockInjector,
+                mockObjectService,
+                composition;
+
+            // Composition Capability makes use of promise chaining,
+            // so support that, but don't introduce complication of
+            // native promises.
+            function mockPromise(value) {
+                return {
+                    then: function (callback) {
+                        return mockPromise(callback(value));
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    DOMAIN_OBJECT_METHODS
+                );
+
+                mockObjectService = jasmine.createSpyObj(
+                    "objectService",
+                    [ "getObjects" ]
+                );
+
+                mockInjector = {
+                    get: function (name) {
+                        return (name === "objectService") && mockObjectService;
+                    }
+                };
+
+                mockObjectService.getObjects.andReturn(mockPromise([]));
+
+                composition = new CompositionCapability(
+                    mockInjector,
+                    mockDomainObject
+                );
+            });
+
+            it("applies only to models with a composition field", function () {
+                expect(CompositionCapability.appliesTo({ composition: [] }))
+                    .toBeTruthy();
+                expect(CompositionCapability.appliesTo({}))
+                    .toBeFalsy();
+            });
+
+            it("requests ids found in model's composition from the object service", function () {
+                var ids = [ "a", "b", "c", "xyz" ];
+
+                mockDomainObject.getModel.andReturn({ composition: ids });
+
+                composition.invoke();
+
+                expect(mockObjectService.getObjects).toHaveBeenCalledWith(ids);
+            });
+
+            it("adds a context capability to returned domain objects", function () {
+                var result,
+                    mockChild = jasmine.createSpyObj("child", DOMAIN_OBJECT_METHODS);
+
+                mockDomainObject.getModel.andReturn({ composition: ["x"] });
+                mockObjectService.getObjects.andReturn(mockPromise({x: mockChild}));
+                mockChild.getCapability.andReturn(undefined);
+
+                composition.invoke().then(function (c) { result = c; });
+
+                // Should have been added by a wrapper
+                expect(result[0].getCapability('context')).toBeDefined();
+
+            });
 
         });
     }