From 9dd520f17b22cf4b04593bc51f26f0632dc06c13 Mon Sep 17 00:00:00 2001
From: slhale <sarah.hale@nasa.gov>
Date: Wed, 12 Aug 2015 10:06:27 -0700
Subject: [PATCH] [Search] Break up item indexing

Use timeouts to make the generic search's item
indexing not block up the page.
Updated tests accordingly.
---
 platform/search/bundle.json                   |  2 +-
 .../src/services/GenericSearchProvider.js     | 28 ++++++++++++-------
 .../services/GenericSearchProviderSpec.js     | 16 +++++++----
 3 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/platform/search/bundle.json b/platform/search/bundle.json
index 3dba92c859..c15bd25b61 100644
--- a/platform/search/bundle.json
+++ b/platform/search/bundle.json
@@ -39,7 +39,7 @@
                 "provides": "searchService",
                 "type": "provider",
                 "implementation": "services/GenericSearchProvider.js",
-                "depends": [ "$q", "objectService", "workerService", "GENERIC_SEARCH_ROOTS" ]
+                "depends": [ "$q", "$timeout", "objectService", "workerService", "GENERIC_SEARCH_ROOTS" ]
             },
             {
                 "provides": "searchService",
diff --git a/platform/search/src/services/GenericSearchProvider.js b/platform/search/src/services/GenericSearchProvider.js
index a68f5323af..d2a0b4de56 100644
--- a/platform/search/src/services/GenericSearchProvider.js
+++ b/platform/search/src/services/GenericSearchProvider.js
@@ -39,6 +39,7 @@ define(
          *
          * @constructor
          * @param $q Angular's $q, for promise consolidation.
+         * @param $timeout Angular's $timeout, for delayed funtion execution.
          * @param {ObjectService} objectService The service from which
          *        domain objects can be gotten.
          * @param {WorkerService} workerService The service which allows
@@ -46,7 +47,7 @@ define(
          * @param {GENERIC_SEARCH_ROOTS} ROOTS An array of the root 
          *        domain objects' IDs.
          */
-        function GenericSearchProvider($q, objectService, workerService, ROOTS) {
+        function GenericSearchProvider($q, $timeout, objectService, workerService, ROOTS) {
             var worker = workerService.run('genericSearchWorker'),
                 indexed = {},
                 pendingQueries = {};
@@ -132,16 +133,23 @@ define(
                         indexItem(node);
                         indexed[id] = true;
                         
-                        if (node.hasCapability && node.hasCapability('composition')) {
+                        if (node && node.hasCapability && node.hasCapability('composition')) {
                             // This node has children
-                            node.getCapability('composition').invoke().then(function (children) {
-                                // Index the children
-                                if (children.constructor === Array) {
-                                    indexItems(children);
-                                } else {
-                                    indexItems([children]);
-                                }
-                            });
+                            
+                            // Make sure that this is async, so doesn't block up page
+                            $timeout(function () {
+                                // Get the children... 
+                                node.useCapability('composition').then(function (children) {
+                                    $timeout(function () {
+                                        // ... then index the children
+                                        if (children.constructor === Array) {
+                                            indexItems(children);
+                                        } else {
+                                            indexItems([children]);
+                                        }
+                                    }, 100);
+                                });
+                            }, 100);
                         }
                     }
                     
diff --git a/platform/search/test/services/GenericSearchProviderSpec.js b/platform/search/test/services/GenericSearchProviderSpec.js
index 15c7303108..27cba00e89 100644
--- a/platform/search/test/services/GenericSearchProviderSpec.js
+++ b/platform/search/test/services/GenericSearchProviderSpec.js
@@ -31,6 +31,7 @@ define(
 
         describe("The generic search provider ", function () {
             var mockQ,
+                mockTimeout,
                 mockDeferred,
                 mockObjectService,
                 mockObjectPromise,
@@ -57,6 +58,8 @@ define(
                 mockDeferred.promise = "mock promise";
                 mockQ.defer.andReturn(mockDeferred);
                 
+                mockTimeout = jasmine.createSpy("$timeout");
+                
                 mockObjectService = jasmine.createSpyObj(
                     "objectService",
                     [ "getObjects" ]
@@ -83,7 +86,7 @@ define(
                     mockDomainObjects[i] = (
                         jasmine.createSpyObj(
                             "domainObject",
-                            [ "getId", "getModel", "hasCapability", "getCapability" ]
+                            [ "getId", "getModel", "hasCapability", "getCapability", "useCapability" ]
                         )
                     );
                     mockDomainObjects[i].getId.andReturn(i);
@@ -102,14 +105,17 @@ define(
                 mockCapability.invoke.andReturn(mockCapabilityPromise);
                 mockDomainObjects[0].getCapability.andReturn(mockCapability);
                 
-                provider = new GenericSearchProvider(mockQ, mockObjectService, mockWorkerService, mockRoots);
+                provider = new GenericSearchProvider(mockQ, mockTimeout, mockObjectService, mockWorkerService, mockRoots);
             });
             
             it("indexes tree on initialization", function () {
-                mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
-                mockCapabilityPromise.then.mostRecentCall.args[0](mockDomainObjects[1]);
-                
                 expect(mockObjectService.getObjects).toHaveBeenCalled();
+                expect(mockObjectPromise.then).toHaveBeenCalled();
+                
+                mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
+                
+                //mockCapabilityPromise.then.mostRecentCall.args[0](mockDomainObjects[1]);
+                
                 expect(mockWorker.postMessage).toHaveBeenCalled();
             });