ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-06-04 16:40:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Search] Update GenericSearch spec

Browse Source 
nasa/openmctweb#141.
This commit is contained in:
Victor Woeltjen 2015-09-30 17:08:47 -07:00
parent 0d1f3bf87a
commit d04c5e6858
1 changed files with 122 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
platform/search/test/services/GenericSearchProviderSpec.js
View File

@ -31,35 +31,51 @@ define(
describe("The generic search provider ", function () { describe("The generic search provider ", function () {
var mockQ, var mockQ,
mockTimeout, mockLog,
mockThrottle,
mockDeferred, mockDeferred,
mockObjectService, mockObjectService,
mockObjectPromise, mockObjectPromise,
mockChainedPromise,
mockDomainObjects, mockDomainObjects,
mockCapability, mockCapability,
mockCapabilityPromise, mockCapabilityPromise,
mockWorkerService, mockWorkerService,
mockWorker, mockWorker,
mockTopic,
mockMutationTopic,
mockRoots = ['root1', 'root2'], mockRoots = ['root1', 'root2'],
provider, provider,
mockProviderResults; mockProviderResults;
beforeEach(function () { function resolveObjectPromises() {
var i; 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( mockQ = jasmine.createSpyObj(
"$q", "$q",
[ "defer" ] [ "defer" ]
); );
mockLog = jasmine.createSpyObj(
"$log",
[ "error", "warn", "info", "debug" ]
);
mockDeferred = jasmine.createSpyObj( mockDeferred = jasmine.createSpyObj(
"deferred", "deferred",
[ "resolve", "reject"] [ "resolve", "reject"]
); );
mockDeferred.promise = "mock promise"; mockDeferred.promise = "mock promise";
mockQ.defer.andReturn(mockDeferred); mockQ.defer.andReturn(mockDeferred);
mockTimeout = jasmine.createSpy("$timeout"); mockThrottle = jasmine.createSpy("throttle");
mockObjectService = jasmine.createSpyObj( mockObjectService = jasmine.createSpyObj(
"objectService", "objectService",
[ "getObjects" ] [ "getObjects" ]
@ -68,9 +84,14 @@ define(
"promise", "promise",
[ "then", "catch" ] [ "then", "catch" ]
); );
mockChainedPromise = jasmine.createSpyObj(
"chainedPromise",
[ "then" ]
);
mockObjectService.getObjects.andReturn(mockObjectPromise); mockObjectService.getObjects.andReturn(mockObjectPromise);
mockTopic = jasmine.createSpy('topic');
mockWorkerService = jasmine.createSpyObj( mockWorkerService = jasmine.createSpyObj(
"workerService", "workerService",
[ "run" ] [ "run" ]
@ -80,68 +101,104 @@ define(
[ "postMessage" ] [ "postMessage" ]
); );
mockWorkerService.run.andReturn(mockWorker); mockWorkerService.run.andReturn(mockWorker);
mockCapabilityPromise = jasmine.createSpyObj( mockCapabilityPromise = jasmine.createSpyObj(
"promise", "promise",
[ "then", "catch" ] [ "then", "catch" ]
); );
mockDomainObjects = {}; mockDomainObjects = {};
for (i = 0; i < 4; i += 1) { ['a', 'root1', 'root2'].forEach(function (id) {
mockDomainObjects[i] = ( mockDomainObjects[id] = (
jasmine.createSpyObj( jasmine.createSpyObj(
"domainObject", "domainObject",
[ "getId", "getModel", "hasCapability", "getCapability", "useCapability" ] [ "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( mockCapability = jasmine.createSpyObj(
"capability", "capability",
[ "invoke", "listen" ] [ "invoke", "listen" ]
); );
mockCapability.invoke.andReturn(mockCapabilityPromise); mockCapability.invoke.andReturn(mockCapabilityPromise);
mockDomainObjects[0].getCapability.andReturn(mockCapability); mockDomainObjects.a.getCapability.andReturn(mockCapability);
mockMutationTopic = jasmine.createSpyObj(
provider = new GenericSearchProvider(mockQ, mockTimeout, mockObjectService, mockWorkerService, mockRoots); 'mutationTopic',
[ 'listen' ]
);
mockTopic.andCallFake(function (key) {
return key === 'mutation' && mockMutationTopic;
});
mockThrottle.andCallFake(function (fn) {
return fn;
});
mockObjectPromise.then.andReturn(mockChainedPromise);
provider = new GenericSearchProvider(
mockQ,
mockLog,
mockThrottle,
mockObjectService,
mockWorkerService,
mockTopic,
mockRoots
);
}); });
it("indexes tree on initialization", function () { it("indexes tree on initialization", function () {
var i;
expect(mockObjectService.getObjects).toHaveBeenCalled(); expect(mockObjectService.getObjects).toHaveBeenCalled();
expect(mockObjectPromise.then).toHaveBeenCalled(); expect(mockObjectPromise.then).toHaveBeenCalled();
// Call through the root-getting part // 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 });
mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
resolveObjectPromises();
// Call through listening for changes resolveObjectPromises();
expect(mockCapability.listen).toHaveBeenCalled();
mockCapability.listen.mostRecentCall.args[0](mockListener); expect(mockWorker.postMessage).toHaveBeenCalledWith({
expect(mockObjectService.getObjects).toHaveBeenCalled(); request: 'index',
mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects); model: mockDomainObjects.a.getModel(),
id: 'a'
});
}); });
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 () { it("sends search queries to the worker", function () {
var timestamp = Date.now(); var timestamp = Date.now();
provider.query(' test "query" ', timestamp, 1, 2); provider.query(' test "query" ', timestamp, 1, 2);
@ -153,20 +210,20 @@ define(
timeout: 2 timeout: 2
}); });
}); });
it("gives an empty result for an empty query", function () { it("gives an empty result for an empty query", function () {
var timestamp = Date.now(), var timestamp = Date.now(),
queryOutput; queryOutput;
queryOutput = provider.query('', timestamp, 1, 2); queryOutput = provider.query('', timestamp, 1, 2);
expect(queryOutput.hits).toEqual([]); expect(queryOutput.hits).toEqual([]);
expect(queryOutput.total).toEqual(0); expect(queryOutput.total).toEqual(0);
queryOutput = provider.query(); queryOutput = provider.query();
expect(queryOutput.hits).toEqual([]); expect(queryOutput.hits).toEqual([]);
expect(queryOutput.total).toEqual(0); expect(queryOutput.total).toEqual(0);
}); });
it("handles responses from the worker", function () { it("handles responses from the worker", function () {
var timestamp = Date.now(), var timestamp = Date.now(),
event = { event = {
@ -181,13 +238,22 @@ define(
timestamp: timestamp timestamp: timestamp
} }
}; };
provider.query(' test "query" ', timestamp); provider.query(' test "query" ', timestamp);
mockWorker.onmessage(event); mockWorker.onmessage(event);
mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects); mockObjectPromise.then.mostRecentCall.args[0](mockDomainObjects);
expect(mockDeferred.resolve).toHaveBeenCalled(); 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();
});
}); });
} }
); );