[Common UI] Fill in spec for RemoveAction

Fill in spec for the Remove action, included as part of
the bundle platform/commonUI/edit. WTD-574.

platform/commonUI/edit/src/actions/RemoveAction.js

@@ -77,13 +77,13 @@ define(
         }
 
         // Object needs to have a parent for Remove to be applicable
-        /*RemoveAction.appliesTo = function (context) {
-            var object = context.domainObject,
+        RemoveAction.appliesTo = function (context) {
+            var object = (context || {}).domainObject,
                 contextCapability = object && object.getCapability("context"),
                 parent = contextCapability && contextCapability.getParent();
             return parent !== undefined &&
                     Array.isArray(parent.getModel().composition);
-        };*/
+        };
 
         return RemoveAction;
     }

platform/commonUI/edit/test/actions/RemoveActionSpec.js

@@ -1,4 +1,4 @@
-/*global define,describe,it,expect,beforeEach,jasmine*/
+/*global define,describe,it,expect,beforeEach,jasmine,spyOn*/
 
 define(
     ["../../src/actions/RemoveAction"],
@@ -6,6 +6,101 @@ define(
         "use strict";
 
         describe("The Remove action", function () {
+            var mockQ,
+                mockDomainObject,
+                mockParent,
+                mockContext,
+                mockMutation,
+                mockPersistence,
+                actionContext,
+                model,
+                capabilities,
+                action;
+
+            function mockPromise(value) {
+                return {
+                    then: function (callback) {
+                        return mockPromise(callback(value));
+                    }
+                };
+            }
+
+            beforeEach(function () {
+
+
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getId", "getCapability" ]
+                );
+                mockQ = { when: mockPromise };
+                mockParent = {
+                    getModel: function () {
+                        return model;
+                    },
+                    getCapability: function (k) {
+                        return capabilities[k];
+                    },
+                    useCapability: function (k, v) {
+                        return capabilities[k].invoke(v);
+                    }
+                };
+                mockContext = jasmine.createSpyObj("context", [ "getParent" ]);
+                mockMutation = jasmine.createSpyObj("mutation", [ "invoke" ]);
+                mockPersistence = jasmine.createSpyObj("persistence", [ "persist" ]);
+
+                mockDomainObject.getId.andReturn("test");
+                mockDomainObject.getCapability.andReturn(mockContext);
+                mockContext.getParent.andReturn(mockParent);
+
+
+
+                capabilities = {
+                    mutation: mockMutation,
+                    persistence: mockPersistence
+                };
+                model = {
+                    composition: [ "a", "test", "b", "c" ]
+                };
+
+                actionContext = { domainObject: mockDomainObject };
+
+                action = new RemoveAction(mockQ, actionContext);
+            });
+
+            it("only applies to objects with parents", function () {
+                expect(RemoveAction.appliesTo(actionContext)).toBeTruthy();
+
+                mockContext.getParent.andReturn(undefined);
+
+                expect(RemoveAction.appliesTo(actionContext)).toBeFalsy();
+            });
+
+            it("mutates the parent when performed", function () {
+                action.perform();
+                expect(mockMutation.invoke)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+            });
+
+            it("changes composition from its mutation function", function () {
+                var mutator, result;
+                action.perform();
+                mutator = mockMutation.invoke.mostRecentCall.args[0];
+                result = mutator(model);
+
+                // Should not have cancelled the mutation
+                expect(result).not.toBe(false);
+
+                // Simulate mutate's behavior (remove can either return a
+                // new model or modify this one in-place)
+                result = result || model;
+
+                // Should have removed "test" - that was our
+                // mock domain object's id.
+                expect(result.composition).toEqual(["a", "b", "c"]);
+
+                // Finally, should have persisted
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
 
         });
     }