[Search] Update GenericSearch spec

nasa/openmctweb#141.

platform/search/test/services/GenericSearchProviderSpec.js

@@ -31,26 +31,42 @@ define(
 
         describe("The generic search provider ", function () {
             var mockQ,
-                mockTimeout,
+                mockLog,
+                mockThrottle,
                 mockDeferred,
                 mockObjectService,
                 mockObjectPromise,
+                mockChainedPromise,
                 mockDomainObjects,
                 mockCapability,
                 mockCapabilityPromise,
                 mockWorkerService,
                 mockWorker,
+                mockTopic,
+                mockMutationTopic,
                 mockRoots = ['root1', 'root2'],
                 provider,
                 mockProviderResults;
 
-            beforeEach(function () {
+            function resolveObjectPromises() {
                 var i;
+                for (i = 0; i < mockObjectPromise.then.calls.length; i += 1) {
+                    mockChainedPromise.then.calls[i].args[0](
+                        mockObjectPromise.then.calls[i]
+                            .args[0](mockDomainObjects)
+                    );
+                }
+            }
 
+            beforeEach(function () {
                 mockQ = jasmine.createSpyObj(
                     "$q",
                     [ "defer" ]
                 );
+                mockLog = jasmine.createSpyObj(
+                    "$log",
+                    [ "error", "warn", "info", "debug" ]
+                );
                 mockDeferred = jasmine.createSpyObj(
                     "deferred",
                     [ "resolve", "reject"]
@@ -58,7 +74,7 @@ define(
                 mockDeferred.promise = "mock promise";
                 mockQ.defer.andReturn(mockDeferred);
 
-                mockTimeout = jasmine.createSpy("$timeout");
+                mockThrottle = jasmine.createSpy("throttle");
 
                 mockObjectService = jasmine.createSpyObj(
                     "objectService",
@@ -68,8 +84,13 @@ define(
                     "promise",
                     [ "then", "catch" ]
                 );
+                mockChainedPromise = jasmine.createSpyObj(
+                    "chainedPromise",
+                    [ "then" ]
+                );
                 mockObjectService.getObjects.andReturn(mockObjectPromise);
 
+                mockTopic = jasmine.createSpy('topic');
 
                 mockWorkerService = jasmine.createSpyObj(
                     "workerService",
@@ -87,59 +108,95 @@ define(
                 );
 
                 mockDomainObjects = {};
-                for (i = 0; i < 4; i += 1) {
+                ['a', 'root1', 'root2'].forEach(function (id) {
-                    mockDomainObjects[i] = (
+                    mockDomainObjects[id] = (
                         jasmine.createSpyObj(
                             "domainObject",
                             [ "getId", "getModel", "hasCapability", "getCapability", "useCapability" ]
                         )
                     );
-                    mockDomainObjects[i].getId.andReturn(i);
+                    mockDomainObjects[id].getId.andReturn(id);
-                    mockDomainObjects[i].getCapability.andReturn(mockCapability);
+                    mockDomainObjects[id].getCapability.andReturn(mockCapability);
-                    mockDomainObjects[i].useCapability.andReturn(mockCapabilityPromise);
+                    mockDomainObjects[id].useCapability.andReturn(mockCapabilityPromise);
-                }
+                    mockDomainObjects[id].getModel.andReturn({});
-                // Give the first object children
+                });
-                mockDomainObjects[0].hasCapability.andReturn(true);
+
                 mockCapability = jasmine.createSpyObj(
                     "capability",
                     [ "invoke", "listen" ]
                 );
                 mockCapability.invoke.andReturn(mockCapabilityPromise);
-                mockDomainObjects[0].getCapability.andReturn(mockCapability);
+                mockDomainObjects.a.getCapability.andReturn(mockCapability);
+                mockMutationTopic = jasmine.createSpyObj(
+                    'mutationTopic',
+                    [ 'listen' ]
+                );
+                mockTopic.andCallFake(function (key) {
+                    return key === 'mutation' && mockMutationTopic;
+                });
+                mockThrottle.andCallFake(function (fn) {
+                    return fn;
+                });
+                mockObjectPromise.then.andReturn(mockChainedPromise);
 
-                provider = new GenericSearchProvider(mockQ, mockTimeout, mockObjectService, mockWorkerService, mockRoots);
+
+                provider = new GenericSearchProvider(
+                    mockQ,
+                    mockLog,
+                    mockThrottle,
+                    mockObjectService,
+                    mockWorkerService,
+                    mockTopic,
+                    mockRoots
+                );
             });
 
             it("indexes tree on initialization", function () {
+                var i;
+
                 expect(mockObjectService.getObjects).toHaveBeenCalled();
                 expect(mockObjectPromise.then).toHaveBeenCalled();
 
                 // Call through the root-getting part
-                mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
+                resolveObjectPromises();
 
-                // Call through the children-getting part 
+                mockRoots.forEach(function (id) {
-                mockTimeout.mostRecentCall.args[0]();
+                    expect(mockWorker.postMessage).toHaveBeenCalledWith({
-                // Array argument indicates multiple children
+                        request: 'index',
-                mockCapabilityPromise.then.mostRecentCall.args[0]([]);
+                        model: mockDomainObjects[id].getModel(),
-                mockTimeout.mostRecentCall.args[0]();
+                        id: id
-                // Call again, but for single child
+                    });
-                mockCapabilityPromise.then.mostRecentCall.args[0]({});
+                });
-                mockTimeout.mostRecentCall.args[0]();
-                
-                expect(mockWorker.postMessage).toHaveBeenCalled();
             });
 
-            it("when indexing, listens for composition changes", function () {
+            it("indexes members of composition", function () {
-                var mockListener = {composition: {}};
+                mockDomainObjects.root1.getModel.andReturn({
+                    composition: ['a']
+                });
 
-                // Call indexItems
+                resolveObjectPromises();
-                mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
+                resolveObjectPromises();
 
-                // Call through listening for changes
+                expect(mockWorker.postMessage).toHaveBeenCalledWith({
-                expect(mockCapability.listen).toHaveBeenCalled();
+                    request: 'index',
-                mockCapability.listen.mostRecentCall.args[0](mockListener);
+                    model: mockDomainObjects.a.getModel(),
-                expect(mockObjectService.getObjects).toHaveBeenCalled();
+                    id: 'a'
-                mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
+                });
+            });
+
+            it("listens for changes to mutation", function () {
+                expect(mockMutationTopic.listen)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+                mockMutationTopic.listen.mostRecentCall
+                    .args[0](mockDomainObjects.a);
+
+                resolveObjectPromises();
+
+                expect(mockWorker.postMessage).toHaveBeenCalledWith({
+                    request: 'index',
+                    model: mockDomainObjects.a.getModel(),
+                    id: mockDomainObjects.a.getId()
+                });
             });
 
             it("sends search queries to the worker", function () {
@@ -188,6 +245,15 @@ define(
                 expect(mockDeferred.resolve).toHaveBeenCalled();
             });
 
+            it("warns when objects are unavailable", function () {
+                resolveObjectPromises();
+                expect(mockLog.warn).not.toHaveBeenCalled();
+                mockChainedPromise.then.mostRecentCall.args[0](
+                    mockObjectPromise.then.mostRecentCall.args[1]()
+                );
+                expect(mockLog.warn).toHaveBeenCalled();
+            });
+
         });
     }
 );