diff --git a/platform/containment/test/CapabilityTableSpec.js b/platform/containment/test/CapabilityTableSpec.js
index a3888f6ae6..5f6612dce4 100644
--- a/platform/containment/test/CapabilityTableSpec.js
+++ b/platform/containment/test/CapabilityTableSpec.js
@@ -5,6 +5,61 @@ define(
     function (CapabilityTable) {
         "use strict";
         describe("Composition policy's capability table", function () {
+            var mockTypeService,
+                mockCapabilityService,
+                mockTypes,
+                table;
+
+            beforeEach(function () {
+                mockTypeService = jasmine.createSpyObj(
+                    'typeService',
+                    [ 'listTypes' ]
+                );
+                mockCapabilityService = jasmine.createSpyObj(
+                    'capabilityService',
+                    [ 'getCapabilities' ]
+                );
+                // Both types can only contain b, let's say
+                mockTypes = ['a', 'b'].map(function (type, index) {
+                    var mockType = jasmine.createSpyObj(
+                        'type-' + type,
+                        ['getKey', 'getDefinition', 'getInitialModel']
+                    );
+                    mockType.getKey.andReturn(type);
+                    // Return a model to drive apparant capabilities
+                    mockType.getInitialModel.andReturn({ id: type });
+                    return mockType;
+                });
+
+                mockTypeService.listTypes.andReturn(mockTypes);
+                mockCapabilityService.getCapabilities.andCallFake(function (model) {
+                    var capabilities = {};
+                    capabilities[model.id + '-capability'] = true;
+                    return capabilities;
+                });
+
+                table = new CapabilityTable(
+                    mockTypeService,
+                    mockCapabilityService
+                );
+            });
+
+            it("provides for lookup of capabilities by type", function () {
+                // Based on initial model, should report the presence
+                // of particular capabilities - suffixed above with -capability
+                expect(table.hasCapability('a', 'a-capability'))
+                    .toBeTruthy();
+                expect(table.hasCapability('a', 'b-capability'))
+                    .toBeFalsy();
+                expect(table.hasCapability('a', 'c-capability'))
+                    .toBeFalsy();
+                expect(table.hasCapability('b', 'a-capability'))
+                    .toBeFalsy();
+                expect(table.hasCapability('b', 'b-capability'))
+                    .toBeTruthy();
+                expect(table.hasCapability('b', 'c-capability'))
+                    .toBeFalsy();
+            });
 
         });
     }
diff --git a/platform/containment/test/CompositionPolicySpec.js b/platform/containment/test/CompositionPolicySpec.js
index 95ea6f238d..bb9720d441 100644
--- a/platform/containment/test/CompositionPolicySpec.js
+++ b/platform/containment/test/CompositionPolicySpec.js
@@ -48,6 +48,8 @@ define(
                 policy = new CompositionPolicy(mockInjector);
             });
 
+            // Test basic composition policy here; test more closely at
+            // the unit level in ContainmentTable for 'has' support, et al
             it("enforces containment rules defined by types", function () {
                 expect(policy.allow(mockTypes[0], mockTypes[1]))
                     .toBeTruthy();
diff --git a/platform/containment/test/ContainmentTableSpec.js b/platform/containment/test/ContainmentTableSpec.js
index 1e5b718a0d..209a5c97fc 100644
--- a/platform/containment/test/ContainmentTableSpec.js
+++ b/platform/containment/test/ContainmentTableSpec.js
@@ -5,6 +5,72 @@ define(
     function (ContainmentTable) {
         "use strict";
         describe("Composition policy's containment table", function () {
+            var mockTypeService,
+                mockCapabilityService,
+                mockTypes,
+                table;
+
+            beforeEach(function () {
+                mockTypeService = jasmine.createSpyObj(
+                    'typeService',
+                    [ 'listTypes' ]
+                );
+                mockCapabilityService = jasmine.createSpyObj(
+                    'capabilityService',
+                    [ 'getCapabilities' ]
+                );
+                // Both types can only contain b, let's say
+                mockTypes = ['a', 'b', 'c'].map(function (type, index) {
+                    var mockType = jasmine.createSpyObj(
+                        'type-' + type,
+                        ['getKey', 'getDefinition', 'getInitialModel']
+                    );
+                    mockType.getKey.andReturn(type);
+                    mockType.getDefinition.andReturn({
+                        // First two contain objects with capability 'b';
+                        // third one defines no containership rules
+                        contains: (index < 2) ? [ { has: 'b' } ] : undefined
+                    });
+                    // Return a model to drive apparant capabilities
+                    mockType.getInitialModel.andReturn({ id: type });
+                    return mockType;
+                });
+
+                mockTypeService.listTypes.andReturn(mockTypes);
+                mockCapabilityService.getCapabilities.andCallFake(function (model) {
+                    var capabilities = {};
+                    capabilities[model.id] = true;
+                    return capabilities;
+                });
+
+                table = new ContainmentTable(
+                    mockTypeService,
+                    mockCapabilityService
+                );
+            });
+
+            // The plain type case is tested in CompositionPolicySpec,
+            // so just test for special syntax ('has', or no contains rules) here
+            it("enforces 'has' containment rules related to capabilities", function () {
+                expect(table.canContain(mockTypes[0], mockTypes[1]))
+                    .toBeTruthy();
+                expect(table.canContain(mockTypes[1], mockTypes[1]))
+                    .toBeTruthy();
+                expect(table.canContain(mockTypes[1], mockTypes[0]))
+                    .toBeFalsy();
+                expect(table.canContain(mockTypes[0], mockTypes[0]))
+                    .toBeFalsy();
+            });
+
+            it("allows anything when no containership rules are defined", function () {
+                expect(table.canContain(mockTypes[2], mockTypes[0]))
+                    .toBeTruthy();
+                expect(table.canContain(mockTypes[2], mockTypes[1]))
+                    .toBeTruthy();
+                expect(table.canContain(mockTypes[2], mockTypes[2]))
+                    .toBeTruthy();
+            });
+
 
         });
     }