Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/js/common/tests/shell/shell-edge.js

649 lines
20 KiB
JavaScript
Raw Blame History

/*jshint globalstrict:false, strict:false */
/*global assertEqual, assertMatch, assertTypeOf, fail */
////////////////////////////////////////////////////////////////////////////////
/// @brief test the document interface
///
/// @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 Dr. Frank Celler
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
var jsunity = require("jsunity");
var arangodb = require("@arangodb");
var ArangoCollection = arangodb.ArangoCollection;
var db = arangodb.db;
var ERRORS = arangodb.errors;
var wait = require("internal").wait;
var testHelper = require("@arangodb/test-helper").Helper;
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite: error handling
////////////////////////////////////////////////////////////////////////////////
function CollectionEdgeSuiteErrorHandling () {
var vn = "UnitTestsCollectionVertex";
var vertex = null;
var en = "UnitTestsCollectionEdge";
var edge = null;
var v1 = null;
var v2 = null;
return {
////////////////////////////////////////////////////////////////////////////////
/// @brief set up
////////////////////////////////////////////////////////////////////////////////
setUp : function () {
db._drop(en);
edge = db._createEdgeCollection(en, { waitForSync : false });
db._drop(vn);
vertex = db._create(vn, { waitForSync : false });
v1 = vertex.save({ a : 1 });
v2 = vertex.save({ a : 2 });
},
////////////////////////////////////////////////////////////////////////////////
/// @brief tear down
////////////////////////////////////////////////////////////////////////////////
tearDown : function () {
edge.unload();
edge.drop();
edge = null;
wait(0.0);
vertex.unload();
vertex.drop();
vertex = null;
wait(0.0);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief bad handle
////////////////////////////////////////////////////////////////////////////////
testErrorHandlingBadHandle : function () {
try {
edge.save(" 123456", v1, {});
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
try {
edge.save(v1, "123456 ", {});
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
try {
edge.save(v1, "1234/56/46", {});
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
}
};
}
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite: normal operations
////////////////////////////////////////////////////////////////////////////////
function CollectionEdgeSuite () {
var vn = "UnitTestsCollectionVertex";
var vertex = null;
var en = "UnitTestsCollectionEdge";
var edge = null;
var v1 = null;
var v2 = null;
return {
////////////////////////////////////////////////////////////////////////////////
/// @brief set up
////////////////////////////////////////////////////////////////////////////////
setUp : function () {
db._drop(en);
edge = db._createEdgeCollection(en);
assertEqual(ArangoCollection.TYPE_EDGE, edge.type());
db._drop(vn);
vertex = db._create(vn);
v1 = vertex.save({ a : 1 });
v2 = vertex.save({ a : 2 });
},
////////////////////////////////////////////////////////////////////////////////
/// @brief tear down
////////////////////////////////////////////////////////////////////////////////
tearDown : function () {
edge.drop();
vertex.drop();
edge = null;
vertex = null;
wait(0.0);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief save edge w/ invalid type
////////////////////////////////////////////////////////////////////////////////
testSaveEdgesInvalidType : function () {
[ 1, 2, 3, false, true, null, [ ] ].forEach(function (doc) {
try {
edge.save(v1._key, v2._key, doc);
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_TYPE_INVALID.code, err.errorNum);
}
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief create an edge referring to a vertex documents by keys
////////////////////////////////////////////////////////////////////////////////
testSaveEdgeKeys : function () {
var k1 = vertex.save({ _key: "vx1", vx: 1 });
var k2 = vertex.save({ _key: "vx2", vx: 2 });
var k3 = vertex.save({ _key: "vx3", vx: 3 });
var d1 = vertex.document(k1._key);
assertEqual("vx1", k1._key);
assertEqual(vn + "/vx1", k1._id);
assertEqual("vx1", d1._key);
assertEqual(1, d1.vx);
assertEqual(vn + "/vx1", d1._id);
var d2 = vertex.document(k2._key);
assertEqual("vx2", k2._key);
assertEqual(vn + "/vx2", k2._id);
assertEqual("vx2", d2._key);
assertEqual(2, d2.vx);
assertEqual(vn + "/vx2", d2._id);
var d3 = vertex.document(vn + "/vx3");
assertEqual("vx3", k3._key);
assertEqual(vn + "/vx3", k3._id);
assertEqual("vx3", d3._key);
assertEqual(3, d3.vx);
assertEqual(vn + "/vx3", d3._id);
var e1 = edge.save(vn + "/vx1", vn + "/vx2", { _key: "ex1", connect: "vx1->vx2" });
var e2 = edge.save(vn + "/vx2", vn + "/vx1", { _key: "ex2", connect: "vx2->vx1" });
var e3 = edge.save(vn + "/vx3", vn + "/vx1", { _key: "ex3", connect: "vx3->vx1" });
d1 = edge.document("ex1");
assertEqual("ex1", d1._key);
assertEqual(en + "/ex1", d1._id);
assertEqual(vn + "/vx1", d1._from);
assertEqual(vn + "/vx2", d1._to);
assertEqual("vx1->vx2", d1.connect);
assertEqual("ex1", e1._key);
assertEqual(en + "/ex1", e1._id);
d2 = edge.document("ex2");
assertEqual("ex2", d2._key);
assertEqual(en + "/ex2", d2._id);
assertEqual(vn + "/vx2", d2._from);
assertEqual(vn + "/vx1", d2._to);
assertEqual("vx2->vx1", d2.connect);
assertEqual("ex2", e2._key);
assertEqual(en + "/ex2", e2._id);
d3 = edge.document(en + "/ex3");
assertEqual("ex3", d3._key);
assertEqual(en + "/ex3", d3._id);
assertEqual(vn + "/vx3", d3._from);
assertEqual(vn + "/vx1", d3._to);
assertEqual("vx3->vx1", d3.connect);
assertEqual("ex3", e3._key);
assertEqual(en + "/ex3", e3._id);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief create an edge referring to an unloaded vertex collection
////////////////////////////////////////////////////////////////////////////////
testSaveEdgeUnloaded : function () {
var k1 = vertex.save({ _key: "vx1", vx: 1 });
var k2 = vertex.save({ _key: "vx2", vx: 2 });
assertEqual("vx1", k1._key);
assertEqual(vn + "/vx1", k1._id);
assertEqual("vx2", k2._key);
assertEqual(vn + "/vx2", k2._id);
testHelper.waitUnload(vertex);
testHelper.waitUnload(edge);
var e1 = edge.save(vn + "/vx1", vn + "/vx2", { _key: "ex1", connect: "vx1->vx2" });
var e2 = edge.save(vn + "/vx2", vn + "/vx1", { _key: "ex2", connect: "vx2->vx1" });
testHelper.waitUnload(vertex);
testHelper.waitUnload(edge);
vertex.unload();
edge.unload();
var e3 = edge.save(k1, k2, { _key: "ex3", connect: "vx1->vx2" });
var d1 = edge.document("ex1");
assertEqual("ex1", d1._key);
assertEqual(en + "/ex1", d1._id);
assertEqual(vn + "/vx1", d1._from);
assertEqual(vn + "/vx2", d1._to);
assertEqual("vx1->vx2", d1.connect);
assertEqual("ex1", e1._key);
assertEqual(en + "/ex1", e1._id);
var d2 = edge.document("ex2");
assertEqual("ex2", d2._key);
assertEqual(en + "/ex2", d2._id);
assertEqual(vn + "/vx2", d2._from);
assertEqual(vn + "/vx1", d2._to);
assertEqual("vx2->vx1", d2.connect);
assertEqual("ex2", e2._key);
assertEqual(en + "/ex2", e2._id);
var d3 = edge.document("ex3");
assertEqual("ex3", d3._key);
assertEqual(en + "/ex3", d3._id);
assertEqual(vn + "/vx1", d3._from);
assertEqual(vn + "/vx2", d3._to);
assertEqual("vx1->vx2", d3.connect);
assertEqual("ex3", e3._key);
assertEqual(en + "/ex3", e3._id);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief create an edge
////////////////////////////////////////////////////////////////////////////////
testSaveEdge : function () {
var doc = edge.save(v1, v2, { "Hello" : "World" });
assertTypeOf("string", doc._id);
assertTypeOf("string", doc._rev);
assertMatch(/^UnitTestsCollectionEdge\//, doc._id);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief create an edge that reference non-existing vertex collections
////////////////////////////////////////////////////////////////////////////////
testSaveEdgeInvalidVertexCollection : function () {
[ "UnitTestsCollectionNonExistingVertex/12345",
"UnitTestsCollectionNonExistingVertex/456745"
].forEach(function(key) {
try {
edge.save(key, key, { });
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_COLLECTION_NOT_FOUND.code, err.errorNum);
}
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief create an edge that reference an unloaded collection
////////////////////////////////////////////////////////////////////////////////
testSaveEdgeUnloadedVertexCollection : function () {
vertex.unload();
wait(4);
var e = edge.save(v1._id, v2._id, { });
assertMatch(/^UnitTestsCollectionEdge\//, e._id);
var doc = edge.document(e._id);
assertMatch(/^UnitTestsCollectionEdge\//, doc._id);
assertMatch(/^UnitTestsCollectionVertex\//, doc._from);
assertMatch(/^UnitTestsCollectionVertex\//, doc._to);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief read an edge
////////////////////////////////////////////////////////////////////////////////
testReadEdge : function () {
var d = edge.save(v1, v2, { "Hello" : "World" });
var doc = edge.document(d._id);
assertEqual(d._id, doc._id);
assertEqual(d._rev, doc._rev);
assertEqual(v1._id, doc._from);
assertEqual(v2._id, doc._to);
doc = edge.document(d);
assertEqual(d._id, doc._id);
assertEqual(d._rev, doc._rev);
assertEqual(v1._id, doc._from);
assertEqual(v2._id, doc._to);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief edges query
////////////////////////////////////////////////////////////////////////////////
testReadEdges : function () {
var d1 = edge.save(v1, v2, { "Hello" : "World" });
var d2 = edge.save(v2, v1, { "World" : "Hello" });
var e = edge.edges(v1);
assertEqual(2, e.length);
if (e[0]._id === d1._id) {
assertEqual(v2._id, e[0]._to);
assertEqual(v1._id, e[0]._from);
assertEqual(d2._id, e[1]._id);
assertEqual(v1._id, e[1]._to);
assertEqual(v2._id, e[1]._from);
}
else {
assertEqual(v1._id, e[0]._to);
assertEqual(v2._id, e[0]._from);
assertEqual(d1._id, e[1]._id);
assertEqual(v2._id, e[1]._to);
assertEqual(v1._id, e[1]._from);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief in edges query
////////////////////////////////////////////////////////////////////////////////
testReadInEdges : function () {
var d = edge.save(v1, v2, { "Hello" : "World" });
var e = edge.inEdges(v2);
assertEqual(1, e.length);
assertEqual(d._id, e[0]._id);
assertEqual(v2._id, e[0]._to);
assertEqual(v1._id, e[0]._from);
var f = edge.inEdges(v1);
assertEqual(0, f.length);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief out edges query
////////////////////////////////////////////////////////////////////////////////
testReadOutEdges : function () {
var d = edge.save(v1, v2, { "Hello" : "World" });
var e = edge.outEdges(v1);
assertEqual(1, e.length);
assertEqual(d._id, e[0]._id);
assertEqual(v2._id, e[0]._to);
assertEqual(v1._id, e[0]._from);
var f = edge.outEdges(v2);
assertEqual(0, f.length);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief edges query
////////////////////////////////////////////////////////////////////////////////
testReadEdgesUnloaded : function () {
var d1 = edge.save(v1, v2, { "Hello" : "World" })._id;
var d2 = edge.save(v2, v1, { "World" : "Hello" })._id;
var e1 = edge.document(d1);
var e2 = edge.document(d2);
assertMatch(/^UnitTestsCollectionEdge\//, e1._id);
assertMatch(/^UnitTestsCollectionVertex\//, e1._from);
assertMatch(/^UnitTestsCollectionVertex\//, e1._to);
assertMatch(/^UnitTestsCollectionEdge\//, e2._id);
assertMatch(/^UnitTestsCollectionVertex\//, e2._from);
assertMatch(/^UnitTestsCollectionVertex\//, e2._to);
e1 = null;
e2 = null;
vertex.unload();
edge.unload();
wait(4);
var e = edge.edges(v1);
assertEqual(2, e.length);
if (e[0]._id === d1) {
assertEqual(v2._id, e[0]._to);
assertEqual(v1._id, e[0]._from);
assertEqual(d2, e[1]._id);
assertEqual(v1._id, e[1]._to);
assertEqual(v2._id, e[1]._from);
}
else {
assertEqual(v1._id, e[0]._to);
assertEqual(v2._id, e[0]._from);
assertEqual(d1, e[1]._id);
assertEqual(v2._id, e[1]._to);
assertEqual(v1._id, e[1]._from);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadEdgesInvalid1 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.edges("t/h/e/f/o/x");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadEdgesInvalid2 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.edges("123456 ");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief in edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadInEdgesInvalid1 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.inEdges("the//fox");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief in edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadInEdgesInvalid2 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.inEdges(" 123456 ");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief out edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadOutEdgesInvalid1 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.outEdges("the//fox");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief out edges query invalid
////////////////////////////////////////////////////////////////////////////////
testReadOutEdgesInvalid2 : function () {
edge.save(v1, v2, { "Hello" : "World" });
try {
edge.outEdges("123456 ");
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_HANDLE_BAD.code, err.errorNum);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief invalid collection type for edges
////////////////////////////////////////////////////////////////////////////////
testEdgesCollectionTypeInvalid : function () {
var dn = "UnitTestsCollectionInvalid";
db._drop(dn);
var c = db._create(dn);
try {
c.edges("the fox");
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_COLLECTION_TYPE_INVALID.code, err.errorNum);
}
db._drop(dn);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief read edges of a small graph
////////////////////////////////////////////////////////////////////////////////
testEdgesGraph : function () {
var a = vertex.save( {"name" : "a" });
var b = vertex.save( {"name" : "b" });
var c = vertex.save( {"name" : "c" });
var d = vertex.save( {"name" : "d" });
var e = vertex.save( {"name" : "e" });
var f = vertex.save( {"name" : "f" });
edge.save(a, a, { "what" : "a->a" });
edge.save(a, b, { "what" : "a<->b" });
edge.save(a, c, { "what" : "a->c" });
edge.save(d, a, { "what" : "d->a" });
edge.save(c, d, { "what" : "c->d" });
edge.save(d, f, { "what" : "d<->f" });
edge.save(f, e, { "what" : "f->e" });
edge.save(e, e, { "what" : "e->e" });
assertEqual(3, edge.outEdges(a).length);
assertEqual(0, edge.outEdges(b).length);
assertEqual(1, edge.outEdges(c).length);
assertEqual(2, edge.outEdges(d).length);
assertEqual(1, edge.outEdges(e).length);
assertEqual(1, edge.outEdges(f).length);
assertEqual(2, edge.inEdges(a).length);
assertEqual(1, edge.inEdges(b).length);
assertEqual(1, edge.inEdges(c).length);
assertEqual(1, edge.inEdges(d).length);
assertEqual(2, edge.inEdges(e).length);
assertEqual(1, edge.inEdges(f).length);
assertEqual(4, edge.edges(a).length);
assertEqual(1, edge.edges(b).length);
assertEqual(2, edge.edges(c).length);
assertEqual(3, edge.edges(d).length);
assertEqual(2, edge.edges(e).length);
assertEqual(2, edge.edges(f).length);
}
};
}
////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suites
////////////////////////////////////////////////////////////////////////////////
jsunity.run(CollectionEdgeSuiteErrorHandling);
jsunity.run(CollectionEdgeSuite);
return jsunity.done();
Reference in New Issue View Git Blame Copy Permalink