mirror of https://gitee.com/bigwinds/arangodb
474 lines
12 KiB
JavaScript
474 lines
12 KiB
JavaScript
/*jslint indent: 2, nomen: true, maxlen: 100, white: true plusplus: true */
|
|
/*global beforeEach, afterEach */
|
|
/*global describe, it, expect, jasmine */
|
|
/*global runs, spyOn, waitsFor */
|
|
/*global window, eb, loadFixtures, document, $ */
|
|
/*global EventLibrary*/
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Graph functionality
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2010-2012 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Michael Hackstein
|
|
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
"use strict";
|
|
|
|
describe('Event Library', function () {
|
|
|
|
var eventLib,
|
|
nodeShaperDummy = {},
|
|
edgeShaperDummy = {},
|
|
adapterDummy = {};
|
|
|
|
beforeEach(function() {
|
|
eventLib = new EventLibrary();
|
|
nodeShaperDummy.reshapeNodes = function() {};
|
|
edgeShaperDummy.reshapeEdges = function() {};
|
|
adapterDummy.loadNode = function() {};
|
|
adapterDummy.expandCommunity = function() {};
|
|
spyOn(nodeShaperDummy, "reshapeNodes");
|
|
spyOn(edgeShaperDummy, "reshapeEdges");
|
|
});
|
|
|
|
describe('Expand', function() {
|
|
|
|
var
|
|
config,
|
|
testee;
|
|
|
|
beforeEach(function() {
|
|
adapterDummy.explore = function(){};
|
|
config = {
|
|
startCallback: function() {},
|
|
adapter: adapterDummy,
|
|
reshapeNodes: function() {}
|
|
};
|
|
});
|
|
|
|
it('should call explore on the adapter', function() {
|
|
var node = {
|
|
_id: "0"
|
|
};
|
|
|
|
spyOn(adapterDummy, "explore");
|
|
//config.adapter = adapterDummy.loadNode;
|
|
testee = eventLib.Expand(config);
|
|
testee(node);
|
|
|
|
expect(adapterDummy.explore).wasCalledWith(node, config.startCallback);
|
|
|
|
});
|
|
|
|
it('should call reshape nodes', function() {
|
|
var node = {
|
|
_id: "0"
|
|
};
|
|
spyOn(config, "reshapeNodes");
|
|
testee = eventLib.Expand(config);
|
|
testee(node);
|
|
|
|
expect(config.reshapeNodes).wasCalled();
|
|
|
|
});
|
|
|
|
it('should call the start callback', function() {
|
|
var node = {
|
|
_id: "0"
|
|
};
|
|
|
|
spyOn(config, "startCallback");
|
|
|
|
testee = eventLib.Expand(config);
|
|
testee(node);
|
|
|
|
expect(config.startCallback).wasCalled();
|
|
|
|
});
|
|
|
|
|
|
|
|
describe('setup process', function() {
|
|
|
|
var testConfig = {};
|
|
|
|
it('should throw an error if start callback is not given', function() {
|
|
expect(
|
|
function() {
|
|
eventLib.Expand(testConfig);
|
|
}
|
|
).toThrow("A callback to the Start-method has to be defined");
|
|
});
|
|
|
|
it('should throw an error if load node callback is not given', function() {
|
|
testConfig.startCallback = function(){};
|
|
expect(
|
|
function() {
|
|
eventLib.Expand(testConfig);
|
|
}
|
|
).toThrow("An adapter to load data has to be defined");
|
|
});
|
|
|
|
it('should throw an error if reshape node callback is not given', function() {
|
|
testConfig.startCallback = function(){};
|
|
testConfig.adapter = adapterDummy;
|
|
expect(
|
|
function() {
|
|
eventLib.Expand(testConfig);
|
|
}
|
|
).toThrow("A callback to reshape nodes has to be defined");
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('Drag', function() {
|
|
|
|
describe('setup process', function() {
|
|
|
|
it('should throw an error if layouter is not given', function() {
|
|
var testConfig = {};
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.checkDragConfig(testConfig);
|
|
}
|
|
).toThrow("A layouter has to be defined");
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.Drag(testConfig);
|
|
}
|
|
).toThrow("A layouter has to be defined");
|
|
});
|
|
|
|
it('should throw an error if the layouter does not offer a drag function', function() {
|
|
var testConfig = {
|
|
layouter: {}
|
|
};
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.checkDragConfig(testConfig);
|
|
}
|
|
).toThrow("The layouter has to offer a drag function");
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.Drag(testConfig);
|
|
}
|
|
).toThrow("The layouter has to offer a drag function");
|
|
|
|
testConfig.layouter.drag = 42;
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.checkDragConfig(testConfig);
|
|
}
|
|
).toThrow("The layouter has to offer a drag function");
|
|
|
|
expect(
|
|
function() {
|
|
eventLib.Drag(testConfig);
|
|
}
|
|
).toThrow("The layouter has to offer a drag function");
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('Insert Node', function() {
|
|
|
|
it('should create an event to add a node', function() {
|
|
|
|
var adapterDummy = {},
|
|
nodes = [],
|
|
created = null,
|
|
called = false,
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
testee;
|
|
|
|
runs(function() {
|
|
adapterDummy.createNode = function(nodeToCreate, callback) {
|
|
created = nodeToCreate;
|
|
nodes.push(created);
|
|
callback(created);
|
|
};
|
|
|
|
var nodeEditorConfig = {
|
|
nodes: nodes,
|
|
adapter: adapterDummy,
|
|
shaper: nodeShaperDummy
|
|
};
|
|
|
|
testee = eventLib.InsertNode(nodeEditorConfig);
|
|
testee(callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(created).toBeDefined();
|
|
expect(nodeShaperDummy.reshapeNodes).toHaveBeenCalled();
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('Patch Node', function() {
|
|
|
|
it('should create an event to patch a node', function() {
|
|
var adapterDummy = {},
|
|
patched = {id: "1"},
|
|
data = {hello: "world"},
|
|
nodes = [patched],
|
|
called = false,
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
nodeEditorConfig = {
|
|
nodes: nodes,
|
|
adapter: adapterDummy,
|
|
shaper: nodeShaperDummy
|
|
},
|
|
testee;
|
|
|
|
adapterDummy.patchNode = function(nodeToPatch, patchData, callback) {
|
|
patched = nodeToPatch;
|
|
$.extend(patched, patchData);
|
|
callback();
|
|
};
|
|
|
|
|
|
runs(function() {
|
|
testee = eventLib.PatchNode(nodeEditorConfig);
|
|
testee(patched, data, callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(patched).toBeDefined();
|
|
expect(nodeShaperDummy.reshapeNodes).toHaveBeenCalled();
|
|
expect(patched.id).toEqual("1");
|
|
expect(patched.hello).toEqual("world");
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
describe('Delete Node', function() {
|
|
|
|
it('should create an event to delete a node', function() {
|
|
var adapterDummy = {},
|
|
toDel = {id: "2"},
|
|
nodes = [toDel],
|
|
deleted = null,
|
|
called = false,
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
nodeEditorConfig = {
|
|
nodes: nodes,
|
|
adapter: adapterDummy,
|
|
shaper: nodeShaperDummy
|
|
},
|
|
testee;
|
|
|
|
adapterDummy.deleteNode = function(nodeToDelete, callback) {
|
|
deleted = nodeToDelete;
|
|
nodes.pop();
|
|
callback();
|
|
};
|
|
|
|
|
|
runs(function() {
|
|
testee = eventLib.DeleteNode(nodeEditorConfig);
|
|
testee(toDel, callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(deleted).toEqual(toDel);
|
|
expect(nodeShaperDummy.reshapeNodes).toHaveBeenCalled();
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('Insert Edge', function() {
|
|
|
|
it('should create an event to add an edge', function() {
|
|
var adapterDummy = {},
|
|
edges = [],
|
|
called = false,
|
|
created = null,
|
|
source = {_id: 1},
|
|
target = {_id: 2},
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
edgeEditorConfig = {
|
|
edges: edges,
|
|
adapter: adapterDummy,
|
|
shaper: edgeShaperDummy
|
|
},
|
|
testee;
|
|
|
|
adapterDummy.createEdge = function(edgeToCreate, callback) {
|
|
created = edgeToCreate;
|
|
edges.push(created);
|
|
callback(created);
|
|
};
|
|
|
|
runs(function() {
|
|
testee = eventLib.InsertEdge(edgeEditorConfig);
|
|
testee(source, target, callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(created).toBeDefined();
|
|
expect(edgeShaperDummy.reshapeEdges).toHaveBeenCalled();
|
|
expect(created.source).toEqual(source);
|
|
expect(created.target).toEqual(target);
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('Patch Edge', function() {
|
|
|
|
it('should create an event to patch an edge', function() {
|
|
var adapterDummy = {},
|
|
source = {_id: 1},
|
|
target = {_id: 2},
|
|
patched = {source: source, target: target},
|
|
data = {hello: "world"},
|
|
edges = [patched],
|
|
called = false,
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
edgeEditorConfig = {
|
|
edges: edges,
|
|
adapter: adapterDummy,
|
|
shaper: edgeShaperDummy
|
|
},
|
|
testee;
|
|
|
|
adapterDummy.patchEdge = function(edgeToPatch, patchData, callback) {
|
|
patched = edgeToPatch;
|
|
$.extend(patched, patchData);
|
|
callback();
|
|
};
|
|
|
|
runs(function() {
|
|
testee = eventLib.PatchEdge(edgeEditorConfig);
|
|
testee(patched, data, callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(patched).toBeDefined();
|
|
expect(edgeShaperDummy.reshapeEdges).toHaveBeenCalled();
|
|
expect(patched.source).toEqual(source);
|
|
expect(patched.target).toEqual(target);
|
|
expect(patched.hello).toEqual("world");
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('Delete Edge', function() {
|
|
|
|
it('should create an event to delete an edge', function() {
|
|
var adapterDummy = {},
|
|
source = {_id: 1},
|
|
target = {_id: 2},
|
|
toDel = {source: source, target: target},
|
|
edges = [toDel],
|
|
deleted = null,
|
|
called = false,
|
|
callbackCheck = function() {
|
|
called = true;
|
|
},
|
|
edgeEditorConfig = {
|
|
edges: edges,
|
|
adapter: adapterDummy,
|
|
shaper: edgeShaperDummy
|
|
},
|
|
testee;
|
|
|
|
adapterDummy.deleteEdge = function(edgeToDelete, callback) {
|
|
deleted = edgeToDelete;
|
|
edges.pop();
|
|
callback();
|
|
};
|
|
|
|
|
|
runs(function() {
|
|
testee = eventLib.DeleteEdge(edgeEditorConfig);
|
|
testee(toDel, callbackCheck);
|
|
});
|
|
|
|
waitsFor(function() {
|
|
return called;
|
|
});
|
|
|
|
runs(function() {
|
|
expect(deleted).toEqual(toDel);
|
|
expect(edgeShaperDummy.reshapeEdges).toHaveBeenCalled();
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
});
|
|
|
|
}());
|