mirror of https://gitee.com/bigwinds/arangodb
477 lines
13 KiB
JavaScript
477 lines
13 KiB
JavaScript
/*jshint globalstrict:false, strict:false */
|
|
/*global assertFalse, assertTrue, assertEqual */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test the agency communication layer
|
|
///
|
|
/// @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 Lucas Doomen
|
|
/// @author Copyright 2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var _ = require("underscore"),
|
|
joi = require("joi"),
|
|
jsunity = require("jsunity");
|
|
|
|
function ModelSpec () {
|
|
'use strict';
|
|
var FoxxModel, instance;
|
|
|
|
return {
|
|
setUp: function () {
|
|
FoxxModel = require('org/arangodb/foxx/model').Model;
|
|
},
|
|
|
|
testWithInitialData: function () {
|
|
instance = new FoxxModel({
|
|
a: 1
|
|
});
|
|
|
|
assertEqual(instance.get("a"), 1);
|
|
instance.set("a", 2);
|
|
assertEqual(instance.get("a"), 2);
|
|
},
|
|
|
|
testWithoutInitialData: function () {
|
|
instance = new FoxxModel();
|
|
|
|
assertEqual(instance.get("a"), undefined);
|
|
instance.set("a", 1);
|
|
assertEqual(instance.get("a"), 1);
|
|
},
|
|
|
|
testSettingMultipleAttributes: function () {
|
|
instance = new FoxxModel({
|
|
a: 1,
|
|
b: 9
|
|
});
|
|
|
|
instance.set({
|
|
b: 2,
|
|
c: 3
|
|
});
|
|
|
|
assertEqual(instance.get("a"), 1);
|
|
assertEqual(instance.get("b"), 2);
|
|
assertEqual(instance.get("c"), 3);
|
|
},
|
|
|
|
testAddingAMethodWithExtend: function () {
|
|
var Model = FoxxModel.extend({
|
|
getA: function() {
|
|
return this.get("a");
|
|
}
|
|
});
|
|
|
|
instance = new Model({
|
|
a: 5
|
|
});
|
|
|
|
assertEqual(instance.getA(), 5);
|
|
},
|
|
|
|
testOverwritingAMethodWithExtend: function () {
|
|
var Model = FoxxModel.extend({
|
|
get: function() {
|
|
return 1;
|
|
}
|
|
});
|
|
|
|
instance = new Model({
|
|
a: 5
|
|
});
|
|
|
|
assertEqual(instance.get(), 1);
|
|
},
|
|
|
|
testHas: function () {
|
|
instance = new FoxxModel({
|
|
a: 1,
|
|
b: null
|
|
});
|
|
|
|
assertTrue(instance.has("a"));
|
|
assertFalse(instance.has("b"));
|
|
assertFalse(instance.has("c"));
|
|
},
|
|
|
|
testSerialization: function () {
|
|
var raw = {
|
|
a: 1,
|
|
b: 2
|
|
};
|
|
|
|
instance = new FoxxModel(raw);
|
|
var dbData = instance.forDB();
|
|
var clientData = instance.forClient();
|
|
|
|
_.each(raw, function(value, key) {
|
|
assertEqual(value, dbData[key]);
|
|
assertEqual(value, clientData[key]);
|
|
});
|
|
},
|
|
|
|
testAlwaysAllowMetadataAttributes: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
anInteger: joi.number().integer()
|
|
}
|
|
});
|
|
|
|
instance = new Model({ anInteger: 1 });
|
|
assertEqual(_.keys(instance.attributes).length, 1);
|
|
instance.set("_key", "arango");
|
|
assertEqual(_.keys(instance.attributes).length, 2);
|
|
assertEqual(instance.get("_key"), "arango");
|
|
assertEqual(_.keys(instance.errors).length, 0);
|
|
assertTrue(instance.isValid);
|
|
},
|
|
|
|
testJoiObject: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: joi.object().keys({
|
|
lol: joi.string()
|
|
})
|
|
});
|
|
|
|
instance = new Model({lol: 5});
|
|
assertEqual(_.keys(instance.attributes).length, 1);
|
|
assertEqual(instance.get("lol"), 5);
|
|
assertEqual(_.keys(instance.errors).length, 1);
|
|
assertFalse(instance.isValid);
|
|
},
|
|
|
|
testAttributeDefaults: function () {
|
|
var special = function () {
|
|
return 42;
|
|
};
|
|
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
aString: joi.any().default("potato"),
|
|
special: joi.any().default(special, "current date")
|
|
}
|
|
});
|
|
|
|
instance = new Model();
|
|
assertEqual(instance.get("aString"), "potato");
|
|
assertEqual(instance.get("special"), special());
|
|
},
|
|
|
|
testCoerceAttributes: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
anInteger: joi.number().integer()
|
|
}
|
|
});
|
|
|
|
instance = new Model({anInteger: 1});
|
|
instance.set("anInteger", "2");
|
|
assertEqual(instance.get("anInteger"), 2);
|
|
assertEqual(_.keys(instance.errors).length, 0);
|
|
assertTrue(instance.isValid);
|
|
},
|
|
|
|
testDisallowUnknownAttributes: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
anInteger: joi.number().integer().strict()
|
|
}
|
|
});
|
|
|
|
instance = new Model({ anInteger: 1, nonExistant: 2 });
|
|
assertEqual(instance.attributes.anInteger, 1);
|
|
assertEqual(instance.attributes.nonExistant, 2);
|
|
assertEqual(_.keys(instance.errors).length, 1);
|
|
assertFalse(instance.isValid);
|
|
assertEqual(instance.errors.nonExistant._object, 2);
|
|
assertTrue(instance.errors.nonExistant.message.indexOf("not allowed") !== -1);
|
|
|
|
instance.set('nonExistant', undefined);
|
|
assertEqual(_.keys(instance.errors).length, 0);
|
|
assertTrue(instance.isValid);
|
|
},
|
|
|
|
testDisallowInvalidAttributes: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
anInteger: joi.number().integer().strict()
|
|
}
|
|
});
|
|
|
|
instance = new Model({ anInteger: 1 });
|
|
instance.set("anInteger", undefined);
|
|
assertEqual(instance.attributes.anInteger, undefined);
|
|
instance.set("anInteger", 2);
|
|
assertEqual(instance.attributes.anInteger, 2);
|
|
assertEqual(_.keys(instance.errors).length, 0);
|
|
assertTrue(instance.isValid);
|
|
|
|
instance.set("anInteger", 5.1);
|
|
assertEqual(instance.attributes.anInteger, 5.1);
|
|
assertEqual(_.keys(instance.errors).length, 1);
|
|
assertFalse(instance.isValid);
|
|
assertEqual(instance.errors.anInteger._object, 5.1);
|
|
assertTrue(instance.errors.anInteger.message.indexOf("integer") !== -1);
|
|
|
|
instance.set("anInteger", false);
|
|
assertEqual(instance.attributes.anInteger, false);
|
|
assertEqual(_.keys(instance.errors).length, 1);
|
|
assertFalse(instance.isValid);
|
|
assertEqual(instance.errors.anInteger._object, false);
|
|
assertTrue(instance.errors.anInteger.message.indexOf("number") !== -1);
|
|
|
|
instance.set("anInteger", "");
|
|
assertEqual(instance.attributes.anInteger, "");
|
|
assertEqual(_.keys(instance.errors).length, 1);
|
|
assertFalse(instance.isValid);
|
|
assertEqual(instance.errors.anInteger._object, "");
|
|
assertTrue(instance.errors.anInteger.message.indexOf("number") !== -1);
|
|
|
|
instance.set("anInteger", 4);
|
|
assertEqual(instance.attributes.anInteger, 4);
|
|
assertEqual(_.keys(instance.errors).length, 0);
|
|
assertTrue(instance.isValid);
|
|
},
|
|
|
|
testFilterMetadata: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
a: joi.number().integer()
|
|
}
|
|
});
|
|
|
|
var raw = {
|
|
a: 1,
|
|
_key: 2
|
|
};
|
|
|
|
instance = new Model(raw);
|
|
var dbData = instance.forDB();
|
|
var clientData = instance.forClient();
|
|
|
|
assertEqual(_.keys(dbData).length, 2);
|
|
assertEqual(_.keys(clientData).length, 1);
|
|
assertEqual(dbData.a, raw.a);
|
|
assertEqual(dbData._key, raw._key);
|
|
assertEqual(clientData.a, raw.a);
|
|
},
|
|
|
|
testFromClient: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
a: joi.number().integer()
|
|
}
|
|
});
|
|
|
|
var raw = {
|
|
a: 1,
|
|
_key: 2
|
|
};
|
|
|
|
instance = Model.fromClient(raw);
|
|
assertEqual(_.keys(instance.attributes).length, 1);
|
|
assertEqual(instance.attributes.a, raw.a);
|
|
assertEqual(instance.attributes._key, undefined);
|
|
},
|
|
|
|
testSetDefaultAttributes: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
a: joi.string().default('test'),
|
|
b: joi.string().default('test'),
|
|
c: joi.string()
|
|
}
|
|
});
|
|
|
|
instance = new Model({ a: "a", c: "c" });
|
|
assertEqual(instance.attributes, { a: "a", c: "c", b: "test" });
|
|
}
|
|
};
|
|
}
|
|
|
|
function ModelDBSpec () {
|
|
"use strict";
|
|
var FoxxModel, instance, cn;
|
|
var internal = require("internal");
|
|
var db = require("org/arangodb").db;
|
|
|
|
return {
|
|
setUp: function () {
|
|
FoxxModel = require('org/arangodb/foxx/model').Model;
|
|
|
|
cn = "UnitTestsFoxxModel";
|
|
db._drop(cn);
|
|
db._create(cn);
|
|
},
|
|
|
|
tearDown: function () {
|
|
db._drop(cn);
|
|
},
|
|
|
|
testFromShaped: function () {
|
|
internal.wal.flush(true, true);
|
|
db._collection(cn).insert({ _key: "test" });
|
|
internal.wal.flush(true, true);
|
|
internal.wait(3);
|
|
|
|
// doc should be shaped by now, at least on a single server
|
|
var doc = db._document(cn + "/test");
|
|
|
|
assertTrue(typeof doc._PRINT === 'function' || typeof doc._PRINT === 'undefined');
|
|
instance = new FoxxModel(doc);
|
|
assertEqual(instance.attributes._PRINT, undefined);
|
|
assertFalse(instance.has('_PRINT'));
|
|
},
|
|
|
|
testFromWal: function () {
|
|
internal.wal.flush(true, true);
|
|
db._collection(cn).insert({ _key: "test" });
|
|
|
|
// doc should still be in the WAL, at least on a single server
|
|
var doc = db._document(cn + "/test");
|
|
instance = new FoxxModel(doc);
|
|
assertEqual(instance.attributes._PRINT, undefined);
|
|
assertFalse(instance.has('_PRINT'));
|
|
},
|
|
|
|
testFromDbWithSchema: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
user: joi.string()
|
|
}
|
|
});
|
|
|
|
internal.wal.flush(true, true);
|
|
db._collection(cn).insert({ _key: "test" });
|
|
internal.wal.flush(true, true);
|
|
internal.wait(3);
|
|
|
|
// doc should be shaped by now, at least on a single server
|
|
var doc = db._document(cn + "/test");
|
|
|
|
assertTrue(typeof doc._PRINT === 'function' || typeof doc._PRINT === 'undefined');
|
|
instance = new Model(doc);
|
|
assertEqual(instance.attributes._PRINT, undefined);
|
|
assertFalse(instance.has('_PRINT'));
|
|
},
|
|
|
|
testSettingFromDb: function () {
|
|
internal.wal.flush(true, true);
|
|
db._collection(cn).insert({ _key: "test" });
|
|
internal.wal.flush(true, true);
|
|
internal.wait(3);
|
|
|
|
// doc should be shaped by now, at least on a single server
|
|
var doc = db._document(cn + "/test");
|
|
|
|
assertTrue(typeof doc._PRINT === 'function' || typeof doc._PRINT === 'undefined');
|
|
instance = new FoxxModel();
|
|
instance.set(doc);
|
|
assertEqual(instance.attributes._PRINT, undefined);
|
|
assertFalse(instance.has('_PRINT'));
|
|
},
|
|
|
|
testSettingFromDbWithSchema: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
user: joi.string()
|
|
}
|
|
});
|
|
|
|
internal.wal.flush(true, true);
|
|
db._collection(cn).insert({ _key: "test" });
|
|
internal.wal.flush(true, true);
|
|
internal.wait(3);
|
|
|
|
// doc should be shaped by now, at least on a single server
|
|
var doc = db._document(cn + "/test");
|
|
|
|
assertTrue(typeof doc._PRINT === 'function' || typeof doc._PRINT === 'undefined');
|
|
instance = new Model();
|
|
instance.set(doc);
|
|
assertEqual(instance.attributes._PRINT, undefined);
|
|
assertFalse(instance.has('_PRINT'));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
function ModelAnnotationSpec () {
|
|
'use strict';
|
|
var FoxxModel, toJSONSchema, jsonSchema, instance;
|
|
|
|
return {
|
|
setUp: function () {
|
|
FoxxModel = require('org/arangodb/foxx/model').Model;
|
|
toJSONSchema = require('org/arangodb/foxx/schema').toJSONSchema;
|
|
},
|
|
|
|
testGetEmptyJSONSchema: function () {
|
|
var Model = FoxxModel.extend({});
|
|
jsonSchema = toJSONSchema("myname", Model);
|
|
assertEqual(jsonSchema.id, "myname");
|
|
assertEqual(jsonSchema.required, undefined);
|
|
assertEqual(jsonSchema.properties, {});
|
|
},
|
|
|
|
testAttributesOfAPlainModel: function () {
|
|
var attributes = {a: 1, b: 2};
|
|
var Model = FoxxModel.extend({});
|
|
instance = new Model(attributes);
|
|
assertEqual(instance.attributes, attributes);
|
|
},
|
|
|
|
testAddOptionalAttributeToJSONSchema: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
x: joi.string()
|
|
}
|
|
});
|
|
|
|
jsonSchema = toJSONSchema("myname", Model);
|
|
assertEqual(jsonSchema.id, "myname");
|
|
assertEqual(jsonSchema.required, undefined);
|
|
assertEqual(jsonSchema.properties.x.type, "string");
|
|
},
|
|
|
|
testAddRequiredAttributeToJSONSchema: function () {
|
|
var Model = FoxxModel.extend({
|
|
schema: {
|
|
x: joi.string().required()
|
|
}
|
|
});
|
|
|
|
jsonSchema = toJSONSchema("myname", Model);
|
|
assertEqual(jsonSchema.id, "myname");
|
|
assertEqual(jsonSchema.properties.x.type, "string");
|
|
assertEqual(jsonSchema.required, ["x"]);
|
|
}
|
|
};
|
|
}
|
|
|
|
jsunity.run(ModelSpec);
|
|
jsunity.run(ModelDBSpec);
|
|
jsunity.run(ModelAnnotationSpec);
|
|
|
|
return jsunity.done();
|