[Common UI] Fill in dialog specs

Fill in specs for bundle platform/commonUI/dialog,
which provides the ability to show dialogs. One
of the common user interface elements being transitioned
for WTD-574.

platform/commonUI/dialog/src/DialogService.js

@@ -40,11 +40,7 @@ define(
 
                     // Temporary workaround, in the absence of a
                     // forms package.
-                    try {
-                        resultingValue = JSON.parse(overlayModel.value);
-                    } catch (e) {
-                        resultingValue = {};
-                    }
+                    resultingValue = JSON.parse(overlayModel.value);
 
                     // Pass along the result
                     deferred.resolve(resultingValue);
@@ -89,6 +85,10 @@ define(
                         overlayModel,
                         "overlay-dialog"
                     );
+
+                    // Track that a dialog is already visible, to
+                    // avoid spawning multiple dialogs at once.
+                    dialogVisible = true;
                 }
 
                 return deferred.promise;

platform/commonUI/dialog/test/DialogServiceSpec.js

@@ -9,21 +9,81 @@ define(
         "use strict";
 
         describe("The dialog service", function () {
+            var mockOverlayService,
+                mockQ,
+                mockLog,
+                mockOverlay,
+                mockDeferred,
+                dialogService;
+
+            beforeEach(function () {
+                mockOverlayService = jasmine.createSpyObj(
+                    "overlayService",
+                    [ "createOverlay" ]
+                );
+                mockQ = jasmine.createSpyObj(
+                    "$q",
+                    [ "defer" ]
+                );
+                mockLog = jasmine.createSpyObj(
+                    "$log",
+                    [ "warn", "info", "debug" ]
+                );
+                mockOverlay = jasmine.createSpyObj(
+                    "overlay",
+                    [ "dismiss" ]
+                );
+                mockDeferred = jasmine.createSpyObj(
+                    "deferred",
+                    [ "resolve", "reject"]
+                );
+                mockDeferred.promise = "mock promise";
+
+                mockQ.defer.andReturn(mockDeferred);
+                mockOverlayService.createOverlay.andReturn(mockOverlay);
+
+                dialogService = new DialogService(
+                    mockOverlayService,
+                    mockQ,
+                    mockLog
+                );
+            });
 
             it("adds an overlay when user input is requested", function () {
-
+                dialogService.getUserInput({}, {});
+                expect(mockOverlayService.createOverlay).toHaveBeenCalled();
             });
 
             it("allows user input to be canceled", function () {
-
+                dialogService.getUserInput({}, { someKey: "some value" });
+                mockOverlayService.createOverlay.mostRecentCall.args[0].cancel();
+                expect(mockDeferred.reject).toHaveBeenCalled();
+                expect(mockDeferred.resolve).not.toHaveBeenCalled();
             });
 
             it("passes back the result of user input when confirmed", function () {
-
+                var value = { someKey: 42 };
+                dialogService.getUserInput({}, value);
+                mockOverlayService.createOverlay.mostRecentCall.args[0].confirm();
+                expect(mockDeferred.reject).not.toHaveBeenCalled();
+                expect(mockDeferred.resolve).toHaveBeenCalledWith(value);
             });
 
             it("logs a warning when a dialog is already showing", function () {
+                dialogService.getUserInput({}, {});
+                expect(mockLog.warn).not.toHaveBeenCalled();
+                dialogService.getUserInput({}, {});
+                expect(mockLog.warn).toHaveBeenCalled();
+                expect(mockDeferred.reject).toHaveBeenCalled();
+            });
 
+            it("can show multiple dialogs if prior ones are dismissed", function () {
+                dialogService.getUserInput({}, {});
+                expect(mockLog.warn).not.toHaveBeenCalled();
+                mockOverlayService.createOverlay.mostRecentCall.args[0].confirm();
+                dialogService.getUserInput({}, {});
+                expect(mockLog.warn).not.toHaveBeenCalled();
+                expect(mockDeferred.reject).not.toHaveBeenCalled();
             });
 
         });

platform/commonUI/dialog/test/OverlayServiceSpec.js

@@ -9,13 +9,70 @@ define(
         "use strict";
 
         describe("The dialog service", function () {
+            var mockDocument,
+                mockCompile,
+                mockRootScope,
+                mockBody,
+                mockTemplate,
+                mockElement,
+                mockScope,
+                overlayService;
+
+            beforeEach(function () {
+                mockDocument = jasmine.createSpyObj("$document", [ "find" ]);
+                mockCompile = jasmine.createSpy("$compile");
+                mockRootScope = jasmine.createSpyObj("$rootScope", [ "$new" ]);
+                mockBody = jasmine.createSpyObj("body", [ "prepend" ]);
+                mockTemplate = jasmine.createSpy("template");
+                mockElement = jasmine.createSpyObj("element", [ "remove" ]);
+                mockScope = jasmine.createSpyObj("scope", [ "$destroy" ]);
+
+                mockDocument.find.andReturn(mockBody);
+                mockCompile.andReturn(mockTemplate);
+                mockRootScope.$new.andReturn(mockScope);
+                mockTemplate.andReturn(mockElement);
+
+                overlayService = new OverlayService(
+                    mockDocument,
+                    mockCompile,
+                    mockRootScope
+                );
+            });
 
             it("prepends an mct-include to create overlays", function () {
+                overlayService.createOverlay({}, "test");
+                expect(mockCompile).toHaveBeenCalled();
+                expect(mockCompile.mostRecentCall.args[0].indexOf("mct-include"))
+                    .not.toEqual(-1);
+            });
 
+            it("adds the templated element to the body", function () {
+                overlayService.createOverlay({}, "test");
+                expect(mockBody.prepend).toHaveBeenCalledWith(mockElement);
+            });
+
+            it("places the provided model/key in its template's scope", function () {
+                overlayService.createOverlay({ someKey: 42 }, "test");
+                expect(mockScope.overlay).toEqual({ someKey: 42 });
+                expect(mockScope.key).toEqual("test");
+
+                // Make sure this is actually what was rendered, too
+                expect(mockTemplate).toHaveBeenCalledWith(mockScope);
             });
 
             it("removes the prepended element on request", function () {
+                var overlay = overlayService.createOverlay({}, "test");
 
+                // Verify precondition
+                expect(mockElement.remove).not.toHaveBeenCalled();
+                expect(mockScope.$destroy).not.toHaveBeenCalled();
+
+                // Dismiss the overlay
+                overlay.dismiss();
+
+                // Now it should have been removed, and the scope destroyed
+                expect(mockElement.remove).toHaveBeenCalled();
+                expect(mockScope.$destroy).toHaveBeenCalled();
             });
 
         });