From c1c633db80172051bb364c493ee0a0ea5d04ae65 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Tue, 16 Jun 2015 15:57:08 -0700
Subject: [PATCH] [Addressability] Add test cases

Add test cases to BrowseController which reflect changes for
addressability, WTD-1149.
---
 .../commonUI/browse/src/BrowseController.js   |  1 +
 .../browse/test/BrowseControllerSpec.js       | 80 +++++++++++++++++++
 2 files changed, 81 insertions(+)

diff --git a/platform/commonUI/browse/src/BrowseController.js b/platform/commonUI/browse/src/BrowseController.js
index c1cd84c908..a5713eaeca 100644
--- a/platform/commonUI/browse/src/BrowseController.js
+++ b/platform/commonUI/browse/src/BrowseController.js
@@ -80,6 +80,7 @@ define(
                     // If not, pick a default as the last
                     // root-level component (usually "mine")
                     navigationService.setNavigation(domainObject);
+                    $scope.navigatedObject = domainObject;
                 } else {
                     // Otherwise, just expose the currently navigated object.
                     $scope.navigatedObject = navigationService.getNavigation();
diff --git a/platform/commonUI/browse/test/BrowseControllerSpec.js b/platform/commonUI/browse/test/BrowseControllerSpec.js
index f41f40a8ab..335e2f94eb 100644
--- a/platform/commonUI/browse/test/BrowseControllerSpec.js
+++ b/platform/commonUI/browse/test/BrowseControllerSpec.js
@@ -37,6 +37,7 @@ define(
                 mockNavigationService,
                 mockRootObject,
                 mockDomainObject,
+                mockNextObject,
                 controller;
 
             function mockPromise(value) {
@@ -78,6 +79,10 @@ define(
                     "domainObject",
                     [ "getId", "getCapability", "getModel", "useCapability" ]
                 );
+                mockNextObject = jasmine.createSpyObj(
+                    "nextObject",
+                    [ "getId", "getCapability", "getModel", "useCapability" ]
+                );
 
                 mockObjectService.getObjects.andReturn(mockPromise({
                     ROOT: mockRootObject
@@ -85,6 +90,11 @@ define(
                 mockRootObject.useCapability.andReturn(mockPromise([
                     mockDomainObject
                 ]));
+                mockDomainObject.useCapability.andReturn(mockPromise([
+                    mockNextObject
+                ]));
+                mockNextObject.useCapability.andReturn(undefined);
+                mockNextObject.getId.andReturn("next");
                 mockDomainObject.getId.andReturn("mine");
 
                 controller = new BrowseController(
@@ -140,6 +150,76 @@ define(
                 );
             });
 
+            it("uses route parameters to choose initially-navigated object", function () {
+                mockRoute.current.params.ids = "mine/next";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
+            });
+
+            it("handles invalid IDs by going as far as possible", function () {
+                // Idea here is that if we get a bad path of IDs,
+                // browse controller should traverse down it until
+                // it hits an invalid ID.
+                mockRoute.current.params.ids = "mine/junk";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockDomainObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockDomainObject);
+            });
+
+            it("handles compositionless objects by going as far as possible", function () {
+                // Idea here is that if we get a path which passes
+                // through an object without a composition, browse controller
+                // should stop at it since remaining IDs cannot be loaded.
+                mockRoute.current.params.ids = "mine/next/junk";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
+            });
+
+            it("updates the displayed route to reflect current navigation", function () {
+                var mockContext = jasmine.createSpyObj('context', ['getPath']),
+                    mockUnlisten = jasmine.createSpy('unlisten');
+
+                mockContext.getPath.andReturn(
+                    [mockRootObject, mockDomainObject, mockNextObject]
+                );
+                mockNextObject.getCapability.andCallFake(function (c) {
+                    return c === 'context' && mockContext;
+                });
+                mockScope.$on.andReturn(mockUnlisten);
+                // Provide a navigation change
+                mockNavigationService.addListener.mostRecentCall.args[0](
+                    mockNextObject
+                );
+                expect(mockLocation.path).toHaveBeenCalledWith("/browse/mine/next");
+
+                // Exercise the Angular workaround
+                mockScope.$on.mostRecentCall.args[1]();
+                expect(mockUnlisten).toHaveBeenCalled();
+            });
+
         });
     }
 );