[Edit] Don't wrap non-editable objects

In Edit mode, don't bother wrapping domain objects which should
not be edited even in principle. Avoids insulating these objects
from updates which occur asynchronously, which in turn avoids
WTD-1291.

platform/commonUI/edit/src/objects/EditableDomainObjectCache.js

@@ -68,6 +68,8 @@ define(
                  * @returns {DomainObject} the domain object in an editable form
                  */
                 getEditableObject: function (domainObject) {
+                    var type = domainObject.getCapability('type');
+
                     // Track the top-level domain object; this will have
                     // some special behavior for its context capability.
                     root = root || domainObject;
@@ -77,6 +79,11 @@ define(
                         return domainObject;
                     }
 
+                    // Don't bother wrapping non-editable objects
+                    if (!type || !type.hasFeature('creation')) {
+                        return domainObject;
+                    }
+
                     // Provide an editable form of the object
                     return new EditableDomainObject(
                         domainObject,
@@ -142,4 +149,4 @@ define(
 
         return EditableDomainObjectCache;
     }
-);
+);

platform/commonUI/edit/test/controllers/EditControllerSpec.js

@@ -31,7 +31,7 @@ define(
                 mockQ,
                 mockNavigationService,
                 mockObject,
-                mockCapability,
+                mockType,
                 controller;
 
             beforeEach(function () {
@@ -48,15 +48,18 @@ define(
                     "domainObject",
                     [ "getId", "getModel", "getCapability", "hasCapability" ]
                 );
-                mockCapability = jasmine.createSpyObj(
+                mockType = jasmine.createSpyObj(
-                    "capability",
+                    "type",
-                    [ "invoke" ]
+                    [ "hasFeature" ]
                 );
 
                 mockNavigationService.getNavigation.andReturn(mockObject);
                 mockObject.getId.andReturn("test");
                 mockObject.getModel.andReturn({ name: "Test object" });
-                mockObject.getCapability.andReturn(mockCapability);
+                mockObject.getCapability.andCallFake(function (key) {
+                    return key === 'type' && mockType;
+                });
+                mockType.hasFeature.andReturn(true);
 
                 controller = new EditController(
                     mockScope,
@@ -76,7 +79,7 @@ define(
                     .toBeDefined();
                 // Shouldn't have been the mock capability we provided
                 expect(controller.navigatedObject().getCapability("editor"))
-                    .not.toEqual(mockCapability);
+                    .not.toEqual(mockType);
             });
 
             it("detaches its navigation listener when destroyed", function () {
@@ -119,4 +122,4 @@ define(
 
         });
     }
-);
+);

platform/commonUI/edit/test/objects/EditableDomainObjectCacheSpec.js

@@ -32,6 +32,7 @@ define(
                 completionCapability,
                 object,
                 mockQ,
+                mockType,
                 cache;
 
 
@@ -40,10 +41,13 @@ define(
                 return {
                     getId: function () { return id; },
                     getModel: function () { return {}; },
-                    getCapability: function (name) {
+                    getCapability: function (key) {
-                        return completionCapability;
+                        return {
+                            editor: completionCapability,
+                            type: mockType
+                        }[key];
                     },
-                    hasCapability: function (name) {
+                    hasCapability: function (key) {
                         return false;
                     }
                 };
@@ -62,6 +66,8 @@ define(
 
             beforeEach(function () {
                 mockQ = jasmine.createSpyObj('$q', ['when', 'all']);
+                mockType = jasmine.createSpyObj('type', ['hasFeature']);
+                mockType.hasFeature.andReturn(true);
                 captured = {};
                 completionCapability = {
                     save: function () {
@@ -152,6 +158,17 @@ define(
                     .toBe(wrappedObject);
             });
 
+            it("does not wrap non-editable objects", function () {
+                var domainObject = new TestObject('test-id');
+
+                mockType.hasFeature.andCallFake(function (key) {
+                    return key !== 'creation';
+                });
+
+                expect(cache.getEditableObject(domainObject))
+                    .toBe(domainObject);
+            });
+
 
         });
     }