[Persistence] Test failure handling

Add test cases for handling of Overwrite/Discard choices when
persistence fails due to revision errors. WTD-1033.

platform/persistence/queue/bundle.json

@@ -16,7 +16,6 @@
                     "$q",
                     "$timeout",
                     "dialogService",
-                    "persistenceService",
                     "PERSISTENCE_QUEUE_DELAY"
                 ]
             }

platform/persistence/queue/src/PersistenceFailureHandler.js

@@ -5,7 +5,7 @@ define(
     function (PersistenceFailureDialog, PersistenceFailureConstants) {
         "use strict";
 
-        function PersistenceFailureHandler($q, dialogService, persistenceService) {
+        function PersistenceFailureHandler($q, dialogService) {
             // Refresh revision information for the domain object associated
             // with this persistence failure
             function refresh(failure) {

platform/persistence/queue/src/PersistenceQueue.js

@@ -34,7 +34,6 @@ define(
             $q,
             $timeout,
             dialogService,
-            persistenceService,
             PERSISTENCE_QUEUE_DELAY
         ) {
             // Wire up injected dependencies
@@ -45,8 +44,7 @@ define(
                     $q,
                     new PersistenceFailureHandler(
                         $q,
-                        dialogService,
-                        persistenceService
+                        dialogService
                     )
                 ),
                 PERSISTENCE_QUEUE_DELAY

platform/persistence/queue/test/PersistenceFailureHandlerSpec.js

@@ -2,11 +2,95 @@
 
 
 define(
-    ["../src/PersistenceFailureHandler"],
-    function (PersistenceFailureHandler) {
+    ["../src/PersistenceFailureHandler", "../src/PersistenceFailureConstants"],
+    function (PersistenceFailureHandler, Constants) {
         "use strict";
 
         describe("The persistence failure handler", function () {
+            var mockQ,
+                mockDialogService,
+                mockFailures,
+                mockPromise,
+                handler;
+
+            function asPromise(value) {
+                return (value || {}).then ? value : {
+                    then: function (callback) {
+                        return asPromise(callback(value));
+                    }
+                };
+            }
+
+            function makeMockFailure(id, index) {
+                var mockFailure = jasmine.createSpyObj(
+                        'failure-' + id,
+                        ['requeue']
+                    ),
+                    mockPersistence = jasmine.createSpyObj(
+                        'persistence-' + id,
+                        ['refresh', 'persist']
+                    );
+                mockFailure.domainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getCapability', 'useCapability', 'getModel']
+                );
+                mockFailure.domainObject.getCapability.andCallFake(function (c) {
+                    return (c === 'persistence') && mockPersistence;
+                });
+                mockFailure.domainObject.getModel.andReturn({ id: id, modified: index });
+                mockFailure.persistence = mockPersistence;
+                mockFailure.id = id;
+                mockFailure.error = { key: Constants.REVISION_ERROR_KEY };
+                return mockFailure;
+            }
+
+            beforeEach(function () {
+                mockQ = jasmine.createSpyObj('$q', ['all', 'when']);
+                mockDialogService = jasmine.createSpyObj('dialogService', ['getUserChoice']);
+                mockFailures = ['a', 'b', 'c'].map(makeMockFailure);
+                mockPromise = jasmine.createSpyObj('promise', ['then']);
+                mockDialogService.getUserChoice.andReturn(mockPromise);
+                mockQ.all.andReturn(mockPromise);
+                mockPromise.then.andReturn(mockPromise);
+                handler = new PersistenceFailureHandler(mockQ, mockDialogService);
+            });
+
+            it("shows a dialog to handle failures", function () {
+                handler.handle(mockFailures);
+                expect(mockDialogService.getUserChoice).toHaveBeenCalled();
+            });
+
+            it("overwrites on request", function () {
+                mockQ.all.andReturn(asPromise([]));
+                handler.handle(mockFailures);
+                // User chooses overwrite
+                mockPromise.then.mostRecentCall.args[0](Constants.OVERWRITE_KEY);
+                // Should refresh, remutate, and requeue all objects
+                mockFailures.forEach(function (mockFailure, i) {
+                    expect(mockFailure.persistence.refresh).toHaveBeenCalled();
+                    expect(mockFailure.requeue).toHaveBeenCalled();
+                    expect(mockFailure.domainObject.useCapability).toHaveBeenCalledWith(
+                        'mutation',
+                        jasmine.any(Function),
+                        i // timestamp
+                    );
+                    expect(mockFailure.domainObject.useCapability.mostRecentCall.args[1]())
+                        .toEqual({ id: mockFailure.id, modified: i });
+                });
+            });
+
+            it("discards on request", function () {
+                mockQ.all.andReturn(asPromise([]));
+                handler.handle(mockFailures);
+                // User chooses overwrite
+                mockPromise.then.mostRecentCall.args[0](false);
+                // Should refresh, but not remutate, and requeue all objects
+                mockFailures.forEach(function (mockFailure, i) {
+                    expect(mockFailure.persistence.refresh).toHaveBeenCalled();
+                    expect(mockFailure.requeue).not.toHaveBeenCalled();
+                    expect(mockFailure.domainObject.useCapability).not.toHaveBeenCalled();
+                });
+            });
 
         });
     }