Depend on lb-connector instead of lb-datasource
This commit is contained in:
Simon Ho
parent
26712a7014
commit
37654efc62
14
index.js
14
index.js
|
|
@ -4,3 +4,17 @@ exports.SQLConnector = exports.SqlConnector = require('./lib/sql');
|
|||
exports.ParameterizedSQL = exports.SQLConnector.ParameterizedSQL;
|
||||
exports.Transaction = require('./lib/transaction');
|
||||
|
||||
exports.ModelBuilder = exports.LDL = require('loopback-model/lib/model-builder');
|
||||
exports.DataSource = exports.Schema = require('./lib/datasource.js').DataSource;
|
||||
exports.ModelBaseClass = require('loopback-model/lib/model');
|
||||
exports.GeoPoint = require('loopback-model').Geo.GeoPoint;
|
||||
exports.ValidationError = require('loopback-model/lib/validations').ValidationError;
|
||||
|
||||
Object.defineProperty(exports, 'version', {
|
||||
get: function() {return require('./package.json').version;}
|
||||
});
|
||||
|
||||
var commonTest = './test/common_test';
|
||||
Object.defineProperty(exports, 'test', {
|
||||
get: function() {return require(commonTest);}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -0,0 +1,787 @@
|
|||
var util = require('util');
|
||||
var Connector = require('../..').Connector;
|
||||
var geo = require('loopback-model').Geo;
|
||||
var utils = require('loopback-model/lib/utils');
|
||||
var fs = require('fs');
|
||||
var async = require('async');
|
||||
|
||||
/**
|
||||
* Initialize the Memory connector against the given data source
|
||||
*
|
||||
* @param {DataSource} dataSource The loopback-datasource-juggler dataSource
|
||||
* @param {Function} [callback] The callback function
|
||||
*/
|
||||
exports.initialize = function initializeDataSource(dataSource, callback) {
|
||||
dataSource.connector = new Memory(null, dataSource.settings);
|
||||
dataSource.connector.connect(callback);
|
||||
};
|
||||
|
||||
exports.Memory = Memory;
|
||||
exports.applyFilter = applyFilter;
|
||||
|
||||
function Memory(m, settings) {
|
||||
if (m instanceof Memory) {
|
||||
this.isTransaction = true;
|
||||
this.cache = m.cache;
|
||||
this.ids = m.ids;
|
||||
this.constructor.super_.call(this, 'memory', settings);
|
||||
this._models = m._models;
|
||||
} else {
|
||||
this.isTransaction = false;
|
||||
this.cache = {};
|
||||
this.ids = {};
|
||||
this.constructor.super_.call(this, 'memory', settings);
|
||||
}
|
||||
}
|
||||
|
||||
util.inherits(Memory, Connector);
|
||||
|
||||
Memory.prototype.getDefaultIdType = function() {
|
||||
return Number;
|
||||
};
|
||||
|
||||
Memory.prototype.getTypes = function() {
|
||||
return ['db', 'nosql', 'memory'];
|
||||
};
|
||||
|
||||
Memory.prototype.connect = function (callback) {
|
||||
if (this.isTransaction) {
|
||||
this.onTransactionExec = callback;
|
||||
} else {
|
||||
this.loadFromFile(callback);
|
||||
}
|
||||
};
|
||||
|
||||
function serialize(obj) {
|
||||
if(obj === null || obj === undefined) {
|
||||
return obj;
|
||||
}
|
||||
return JSON.stringify(obj);
|
||||
}
|
||||
|
||||
function deserialize(dbObj) {
|
||||
if(dbObj === null || dbObj === undefined) {
|
||||
return dbObj;
|
||||
}
|
||||
if(typeof dbObj === 'string') {
|
||||
return JSON.parse(dbObj);
|
||||
} else {
|
||||
return dbObj;
|
||||
}
|
||||
}
|
||||
|
||||
Memory.prototype.getCollection = function(model) {
|
||||
var modelClass = this._models[model];
|
||||
if (modelClass && modelClass.settings.memory) {
|
||||
model = modelClass.settings.memory.collection || model;
|
||||
}
|
||||
return model;
|
||||
}
|
||||
|
||||
Memory.prototype.initCollection = function(model) {
|
||||
this.collection(model, {});
|
||||
this.collectionSeq(model, 1);
|
||||
}
|
||||
|
||||
Memory.prototype.collection = function(model, val) {
|
||||
model = this.getCollection(model);
|
||||
if (arguments.length > 1) this.cache[model] = val;
|
||||
return this.cache[model];
|
||||
};
|
||||
|
||||
Memory.prototype.collectionSeq = function(model, val) {
|
||||
model = this.getCollection(model);
|
||||
if (arguments.length > 1) this.ids[model] = val;
|
||||
return this.ids[model];
|
||||
};
|
||||
|
||||
Memory.prototype.loadFromFile = function(callback) {
|
||||
var self = this;
|
||||
var hasLocalStorage = typeof window !== 'undefined' && window.localStorage;
|
||||
var localStorage = hasLocalStorage && this.settings.localStorage;
|
||||
|
||||
if (self.settings.file) {
|
||||
fs.readFile(self.settings.file, {encoding: 'utf8', flag: 'r'}, function (err, data) {
|
||||
if (err && err.code !== 'ENOENT') {
|
||||
callback && callback(err);
|
||||
} else {
|
||||
parseAndLoad(data);
|
||||
}
|
||||
});
|
||||
} else if(localStorage) {
|
||||
var data = window.localStorage.getItem(localStorage);
|
||||
data = data || '{}';
|
||||
parseAndLoad(data);
|
||||
} else {
|
||||
process.nextTick(callback);
|
||||
}
|
||||
|
||||
function parseAndLoad(data) {
|
||||
if (data) {
|
||||
try {
|
||||
data = JSON.parse(data.toString());
|
||||
} catch(e) {
|
||||
return callback(e);
|
||||
}
|
||||
|
||||
self.ids = data.ids || {};
|
||||
self.cache = data.models || {};
|
||||
} else {
|
||||
if(!self.cache) {
|
||||
self.ids = {};
|
||||
self.cache = {};
|
||||
}
|
||||
}
|
||||
callback && callback();
|
||||
}
|
||||
};
|
||||
|
||||
/*!
|
||||
* Flush the cache into the json file if necessary
|
||||
* @param {Function} callback
|
||||
*/
|
||||
Memory.prototype.saveToFile = function (result, callback) {
|
||||
var self = this;
|
||||
var file = this.settings.file;
|
||||
var hasLocalStorage = typeof window !== 'undefined' && window.localStorage;
|
||||
var localStorage = hasLocalStorage && this.settings.localStorage;
|
||||
if (file) {
|
||||
if(!self.writeQueue) {
|
||||
// Create a queue for writes
|
||||
self.writeQueue = async.queue(function (task, cb) {
|
||||
// Flush out the models/ids
|
||||
var data = JSON.stringify({
|
||||
ids: self.ids,
|
||||
models: self.cache
|
||||
}, null, ' ');
|
||||
|
||||
fs.writeFile(self.settings.file, data, function (err) {
|
||||
cb(err);
|
||||
task.callback && task.callback(err, task.data);
|
||||
});
|
||||
}, 1);
|
||||
}
|
||||
// Enqueue the write
|
||||
self.writeQueue.push({
|
||||
data: result,
|
||||
callback: callback
|
||||
});
|
||||
} else if (localStorage) {
|
||||
// Flush out the models/ids
|
||||
var data = JSON.stringify({
|
||||
ids: self.ids,
|
||||
models: self.cache
|
||||
}, null, ' ');
|
||||
window.localStorage.setItem(localStorage, data);
|
||||
process.nextTick(function () {
|
||||
callback && callback(null, result);
|
||||
});
|
||||
} else {
|
||||
process.nextTick(function () {
|
||||
callback && callback(null, result);
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
Memory.prototype.define = function defineModel(definition) {
|
||||
this.constructor.super_.prototype.define.apply(this, [].slice.call(arguments));
|
||||
var m = definition.model.modelName;
|
||||
if(!this.collection(m)) this.initCollection(m);
|
||||
};
|
||||
|
||||
Memory.prototype._createSync = function(model, data, fn) {
|
||||
// FIXME: [rfeng] We need to generate unique ids based on the id type
|
||||
// FIXME: [rfeng] We don't support composite ids yet
|
||||
var currentId = this.collectionSeq(model);
|
||||
if (currentId === undefined) { // First time
|
||||
currentId = this.collectionSeq(model, 1);
|
||||
}
|
||||
var id = this.getIdValue(model, data) || currentId;
|
||||
if (id > currentId) {
|
||||
// If the id is passed in and the value is greater than the current id
|
||||
currentId = id;
|
||||
}
|
||||
this.collectionSeq(model, Number(currentId) + 1);
|
||||
|
||||
var props = this._models[model].properties;
|
||||
var idName = this.idName(model);
|
||||
id = (props[idName] && props[idName].type && props[idName].type(id)) || id;
|
||||
this.setIdValue(model, data, id);
|
||||
if (!this.collection(model)) {
|
||||
this.collection(model, {});
|
||||
}
|
||||
|
||||
if (this.collection(model)[id])
|
||||
return fn(new Error('Duplicate entry for ' + model + '.' + idName));
|
||||
|
||||
this.collection(model)[id] = serialize(data);
|
||||
fn(null, id);
|
||||
};
|
||||
|
||||
Memory.prototype.create = function create(model, data, options, callback) {
|
||||
var self = this;
|
||||
this._createSync(model, data, function(err, id) {
|
||||
if (err) {
|
||||
return process.nextTick(function() {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
self.saveToFile(id, callback);
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.updateOrCreate = function (model, data, options, callback) {
|
||||
var self = this;
|
||||
this.exists(model, self.getIdValue(model, data), options, function (err, exists) {
|
||||
if (exists) {
|
||||
self.save(model, data, options, function(err, data) {
|
||||
callback(err, data, { isNewInstance: false });
|
||||
});
|
||||
} else {
|
||||
self.create(model, data, options, function (err, id) {
|
||||
self.setIdValue(model, data, id);
|
||||
callback(err, data, { isNewInstance: true });
|
||||
});
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.findOrCreate = function(model, filter, data, callback) {
|
||||
var self = this;
|
||||
var nodes = self._findAllSkippingIncludes(model, filter);
|
||||
var found = nodes[0];
|
||||
|
||||
if(!found) {
|
||||
// Calling _createSync to update the collection in a sync way and to guarantee to create it in the same turn of even loop
|
||||
return self._createSync(model, data, function(err, id) {
|
||||
if (err) return callback(err);
|
||||
self.saveToFile(id, function(err, id) {
|
||||
self.setIdValue(model, data, id);
|
||||
callback(err, data, true);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
if (!filter || !filter.include) {
|
||||
return process.nextTick(function() {
|
||||
callback(null, found, false);
|
||||
});
|
||||
}
|
||||
|
||||
self._models[model].model.include(nodes[0], filter.include, {}, function(err, nodes) {
|
||||
process.nextTick(function() {
|
||||
if (err) return callback(err);
|
||||
callback(null, nodes[0], false);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.save = function save(model, data, options, callback) {
|
||||
var self = this;
|
||||
var id = this.getIdValue(model, data);
|
||||
var cachedModels = this.collection(model);
|
||||
var modelData = cachedModels && this.collection(model)[id];
|
||||
modelData = modelData && deserialize(modelData);
|
||||
if (modelData) {
|
||||
data = merge(modelData, data);
|
||||
}
|
||||
this.collection(model)[id] = serialize(data);
|
||||
this.saveToFile(data, function(err) {
|
||||
callback(err, self.fromDb(model, data), { isNewInstance: !modelData });
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.exists = function exists(model, id, options, callback) {
|
||||
process.nextTick(function () {
|
||||
callback(null, this.collection(model) && this.collection(model).hasOwnProperty(id));
|
||||
}.bind(this));
|
||||
};
|
||||
|
||||
Memory.prototype.find = function find(model, id, options, callback) {
|
||||
process.nextTick(function () {
|
||||
callback(null, id in this.collection(model) && this.fromDb(model, this.collection(model)[id]));
|
||||
}.bind(this));
|
||||
};
|
||||
|
||||
Memory.prototype.destroy = function destroy(model, id, options, callback) {
|
||||
var exists = this.collection(model)[id];
|
||||
delete this.collection(model)[id];
|
||||
this.saveToFile({ count: exists ? 1 : 0 }, callback);
|
||||
};
|
||||
|
||||
Memory.prototype.fromDb = function (model, data) {
|
||||
if (!data) return null;
|
||||
data = deserialize(data);
|
||||
var props = this._models[model].properties;
|
||||
for (var key in data) {
|
||||
var val = data[key];
|
||||
if (val === undefined || val === null) {
|
||||
continue;
|
||||
}
|
||||
if (props[key]) {
|
||||
switch (props[key].type.name) {
|
||||
case 'Date':
|
||||
val = new Date(val.toString().replace(/GMT.*$/, 'GMT'));
|
||||
break;
|
||||
case 'Boolean':
|
||||
val = Boolean(val);
|
||||
break;
|
||||
case 'Number':
|
||||
val = Number(val);
|
||||
break;
|
||||
}
|
||||
}
|
||||
data[key] = val;
|
||||
}
|
||||
return data;
|
||||
};
|
||||
|
||||
function getValue(obj, path) {
|
||||
if (obj == null) {
|
||||
return undefined;
|
||||
}
|
||||
var keys = path.split('.');
|
||||
var val = obj;
|
||||
for (var i = 0, n = keys.length; i < n; i++) {
|
||||
val = val[keys[i]];
|
||||
if (val == null) {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
Memory.prototype._findAllSkippingIncludes = function(model, filter) {
|
||||
var nodes = Object.keys(this.collection(model)).map(function (key) {
|
||||
return this.fromDb(model, this.collection(model)[key]);
|
||||
}.bind(this));
|
||||
|
||||
if (filter) {
|
||||
if (!filter.order) {
|
||||
var idNames = this.idNames(model);
|
||||
if (idNames && idNames.length) {
|
||||
filter.order = idNames;
|
||||
}
|
||||
}
|
||||
// do we need some sorting?
|
||||
if (filter.order) {
|
||||
var orders = filter.order;
|
||||
if (typeof filter.order === "string") {
|
||||
orders = [filter.order];
|
||||
}
|
||||
orders.forEach(function (key, i) {
|
||||
var reverse = 1;
|
||||
var m = key.match(/\s+(A|DE)SC$/i);
|
||||
if (m) {
|
||||
key = key.replace(/\s+(A|DE)SC/i, '');
|
||||
if (m[1].toLowerCase() === 'de') reverse = -1;
|
||||
}
|
||||
orders[i] = {"key": key, "reverse": reverse};
|
||||
});
|
||||
nodes = nodes.sort(sorting.bind(orders));
|
||||
}
|
||||
|
||||
var nearFilter = geo.nearFilter(filter.where);
|
||||
|
||||
// geo sorting
|
||||
if (nearFilter) {
|
||||
nodes = geo.filter(nodes, nearFilter);
|
||||
}
|
||||
|
||||
// do we need some filtration?
|
||||
if (filter.where && nodes)
|
||||
nodes = nodes.filter(applyFilter(filter));
|
||||
|
||||
// field selection
|
||||
if (filter.fields) {
|
||||
nodes = nodes.map(utils.selectFields(filter.fields));
|
||||
}
|
||||
|
||||
// limit/skip
|
||||
var skip = filter.skip || filter.offset || 0;
|
||||
var limit = filter.limit || nodes.length;
|
||||
nodes = nodes.slice(skip, skip + limit);
|
||||
}
|
||||
return nodes;
|
||||
|
||||
function sorting(a, b) {
|
||||
var undefinedA, undefinedB;
|
||||
|
||||
for (var i = 0, l = this.length; i < l; i++) {
|
||||
var aVal = getValue(a, this[i].key);
|
||||
var bVal = getValue(b, this[i].key);
|
||||
undefinedB = bVal === undefined && aVal !== undefined;
|
||||
undefinedA = aVal === undefined && bVal !== undefined;
|
||||
|
||||
if (undefinedB || aVal > bVal) {
|
||||
return 1 * this[i].reverse;
|
||||
} else if (undefinedA || aVal < bVal) {
|
||||
return -1 * this[i].reverse;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
Memory.prototype.all = function all(model, filter, options, callback) {
|
||||
var self = this;
|
||||
var nodes = self._findAllSkippingIncludes(model, filter);
|
||||
|
||||
process.nextTick(function() {
|
||||
if (filter && filter.include) {
|
||||
self._models[model].model.include(nodes, filter.include, options, callback);
|
||||
} else {
|
||||
callback(null, nodes);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
function applyFilter(filter) {
|
||||
var where = filter.where;
|
||||
if (typeof where === 'function') {
|
||||
return where;
|
||||
}
|
||||
var keys = Object.keys(where);
|
||||
return function (obj) {
|
||||
return keys.every(function(key) {
|
||||
if(key === 'and' || key === 'or') {
|
||||
if(Array.isArray(where[key])) {
|
||||
if(key === 'and') {
|
||||
return where[key].every(function(cond) {
|
||||
return applyFilter({where: cond})(obj);
|
||||
});
|
||||
}
|
||||
if(key === 'or') {
|
||||
return where[key].some(function(cond) {
|
||||
return applyFilter({where: cond})(obj);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var value = getValue(obj, key);
|
||||
// Support referencesMany and other embedded relations
|
||||
// Also support array types. Mongo, possibly PostgreSQL
|
||||
if (Array.isArray(value)) {
|
||||
var matcher = where[key];
|
||||
// The following condition is for the case where we are querying with
|
||||
// a neq filter, and when the value is an empty array ([]).
|
||||
if (matcher.neq !== undefined && value.length <= 0) {
|
||||
return true;
|
||||
}
|
||||
return value.some(function (v, i) {
|
||||
var filter = {where: {}};
|
||||
filter.where[i] = matcher;
|
||||
return applyFilter(filter)(value);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
if (test(where[key], value)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// If we have a composed key a.b and b would resolve to a property of an object inside an array
|
||||
// then, we attempt to emulate mongo db matching. Helps for embedded relations
|
||||
var dotIndex = key.indexOf('.');
|
||||
var subValue = obj[key.substring(0, dotIndex)];
|
||||
if (dotIndex !== -1 && Array.isArray(subValue)) {
|
||||
var subFilter = {where: {}};
|
||||
var subKey = key.substring(dotIndex+1);
|
||||
subFilter.where[subKey] = where[key];
|
||||
return subValue.some(applyFilter(subFilter));
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
function toRegExp(pattern) {
|
||||
if (pattern instanceof RegExp) {
|
||||
return pattern;
|
||||
}
|
||||
var regex = '';
|
||||
// Escaping user input to be treated as a literal string within a regular expression
|
||||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Writing_a_Regular_Expression_Pattern
|
||||
pattern = pattern.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
|
||||
for (var i = 0, n = pattern.length; i < n; i++) {
|
||||
var char = pattern.charAt(i);
|
||||
if (char === '\\') {
|
||||
i++; // Skip to next char
|
||||
if (i < n) {
|
||||
regex += pattern.charAt(i);
|
||||
}
|
||||
continue;
|
||||
} else if (char === '%') {
|
||||
regex += '.*';
|
||||
} else if (char === '_') {
|
||||
regex += '.';
|
||||
} else if (char === '.') {
|
||||
regex += '\\.';
|
||||
} else if (char === '*') {
|
||||
regex += '\\*';
|
||||
}
|
||||
else {
|
||||
regex += char;
|
||||
}
|
||||
}
|
||||
return regex;
|
||||
}
|
||||
|
||||
function test(example, value) {
|
||||
if (typeof value === 'string' && (example instanceof RegExp)) {
|
||||
return value.match(example);
|
||||
}
|
||||
|
||||
if (example === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (typeof example === 'object' && example !== null) {
|
||||
if (example.regexp) {
|
||||
return value ? value.match(example.regexp) : false;
|
||||
}
|
||||
|
||||
// ignore geo near filter
|
||||
if (example.near) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (example.inq) {
|
||||
// if (!value) return false;
|
||||
for (var i = 0; i < example.inq.length; i++) {
|
||||
if (example.inq[i] == value) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if ('neq' in example) {
|
||||
return compare(example.neq, value) !== 0;
|
||||
}
|
||||
|
||||
if ('between' in example ) {
|
||||
return ( testInEquality({gte:example.between[0]}, value) &&
|
||||
testInEquality({lte:example.between[1]}, value) );
|
||||
}
|
||||
|
||||
if (example.like || example.nlike) {
|
||||
|
||||
var like = example.like || example.nlike;
|
||||
if (typeof like === 'string') {
|
||||
like = toRegExp(like);
|
||||
}
|
||||
if (example.like) {
|
||||
return !!new RegExp(like).test(value);
|
||||
}
|
||||
|
||||
if (example.nlike) {
|
||||
return !new RegExp(like).test(value);
|
||||
}
|
||||
}
|
||||
|
||||
if (testInEquality(example, value)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// not strict equality
|
||||
return (example !== null ? example.toString() : example)
|
||||
== (value != null ? value.toString() : value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two values
|
||||
* @param {*} val1 The 1st value
|
||||
* @param {*} val2 The 2nd value
|
||||
* @returns {number} 0: =, positive: >, negative <
|
||||
* @private
|
||||
*/
|
||||
function compare(val1, val2) {
|
||||
if(val1 == null || val2 == null) {
|
||||
// Either val1 or val2 is null or undefined
|
||||
return val1 == val2 ? 0 : NaN;
|
||||
}
|
||||
if (typeof val1 === 'number') {
|
||||
return val1 - val2;
|
||||
}
|
||||
if (typeof val1 === 'string') {
|
||||
return (val1 > val2) ? 1 : ((val1 < val2) ? -1 : (val1 == val2) ? 0 : NaN);
|
||||
}
|
||||
if (typeof val1 === 'boolean') {
|
||||
return val1 - val2;
|
||||
}
|
||||
if (val1 instanceof Date) {
|
||||
var result = val1 - val2;
|
||||
return result;
|
||||
}
|
||||
// Return NaN if we don't know how to compare
|
||||
return (val1 == val2) ? 0 : NaN;
|
||||
}
|
||||
|
||||
function testInEquality(example, val) {
|
||||
if ('gt' in example) {
|
||||
return compare(val, example.gt) > 0;
|
||||
}
|
||||
if ('gte' in example) {
|
||||
return compare(val, example.gte) >= 0;
|
||||
}
|
||||
if ('lt' in example) {
|
||||
return compare(val, example.lt) < 0;
|
||||
}
|
||||
if ('lte' in example) {
|
||||
return compare(val, example.lte) <= 0;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
Memory.prototype.destroyAll = function destroyAll(model, where, options, callback) {
|
||||
var cache = this.collection(model);
|
||||
var filter = null;
|
||||
var count = 0;
|
||||
if (where) {
|
||||
filter = applyFilter({where: where});
|
||||
Object.keys(cache).forEach(function (id) {
|
||||
if (!filter || filter(this.fromDb(model, cache[id]))) {
|
||||
count++;
|
||||
delete cache[id];
|
||||
}
|
||||
}.bind(this));
|
||||
} else {
|
||||
count = Object.keys(cache).length;
|
||||
this.collection(model, {});
|
||||
}
|
||||
this.saveToFile({ count: count }, callback);
|
||||
};
|
||||
|
||||
Memory.prototype.count = function count(model, where, options, callback) {
|
||||
var cache = this.collection(model);
|
||||
var data = Object.keys(cache);
|
||||
if (where) {
|
||||
var filter = {where: where};
|
||||
data = data.map(function (id) {
|
||||
return this.fromDb(model, cache[id]);
|
||||
}.bind(this));
|
||||
data = data.filter(applyFilter(filter));
|
||||
}
|
||||
process.nextTick(function () {
|
||||
callback(null, data.length);
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.update =
|
||||
Memory.prototype.updateAll = function updateAll(model, where, data, options, cb) {
|
||||
var self = this;
|
||||
var cache = this.collection(model);
|
||||
var filter = null;
|
||||
where = where || {};
|
||||
filter = applyFilter({where: where});
|
||||
|
||||
var ids = Object.keys(cache);
|
||||
var count = 0;
|
||||
async.each(ids, function (id, done) {
|
||||
var inst = self.fromDb(model, cache[id]);
|
||||
if (!filter || filter(inst)) {
|
||||
count++;
|
||||
// The id value from the cache is string
|
||||
// Get the real id from the inst
|
||||
id = self.getIdValue(model, inst);
|
||||
self.updateAttributes(model, id, data, options, done);
|
||||
} else {
|
||||
process.nextTick(done);
|
||||
}
|
||||
}, function (err) {
|
||||
if (err) return cb(err);
|
||||
self.saveToFile({count: count}, cb);
|
||||
});
|
||||
};
|
||||
|
||||
Memory.prototype.updateAttributes = function updateAttributes(model, id, data, options, cb) {
|
||||
if (!id) {
|
||||
var err = new Error('You must provide an id when updating attributes!');
|
||||
if (cb) {
|
||||
return cb(err);
|
||||
} else {
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
// Do not modify the data object passed in arguments
|
||||
data = Object.create(data);
|
||||
|
||||
this.setIdValue(model, data, id);
|
||||
|
||||
var cachedModels = this.collection(model);
|
||||
var modelData = cachedModels && this.collection(model)[id];
|
||||
|
||||
if (modelData) {
|
||||
this.save(model, data, options, cb);
|
||||
} else {
|
||||
cb(new Error('Could not update attributes. Object with id ' + id + ' does not exist!'));
|
||||
}
|
||||
};
|
||||
|
||||
Memory.prototype.transaction = function () {
|
||||
return new Memory(this);
|
||||
};
|
||||
|
||||
Memory.prototype.exec = function (callback) {
|
||||
this.onTransactionExec();
|
||||
setTimeout(callback, 50);
|
||||
};
|
||||
|
||||
Memory.prototype.buildNearFilter = function (filter) {
|
||||
// noop
|
||||
}
|
||||
|
||||
Memory.prototype.automigrate = function (models, cb) {
|
||||
var self = this;
|
||||
|
||||
if ((!cb) && ('function' === typeof models)) {
|
||||
cb = models;
|
||||
models = undefined;
|
||||
}
|
||||
// First argument is a model name
|
||||
if ('string' === typeof models) {
|
||||
models = [models];
|
||||
}
|
||||
|
||||
models = models || Object.keys(self._models);
|
||||
if (models.length === 0) {
|
||||
return process.nextTick(cb);
|
||||
}
|
||||
|
||||
var invalidModels = models.filter(function(m) {
|
||||
return !(m in self._models);
|
||||
});
|
||||
|
||||
if (invalidModels.length) {
|
||||
return process.nextTick(function() {
|
||||
cb(new Error('Cannot migrate models not attached to this datasource: ' +
|
||||
invalidModels.join(' ')));
|
||||
});
|
||||
}
|
||||
|
||||
models.forEach(function(m) {
|
||||
self.initCollection(m);
|
||||
});
|
||||
if (cb) process.nextTick(cb);
|
||||
}
|
||||
|
||||
function merge(base, update) {
|
||||
if (!base) {
|
||||
return update;
|
||||
}
|
||||
// We cannot use Object.keys(update) if the update is an instance of the model
|
||||
// class as the properties are defined at the ModelClass.prototype level
|
||||
for(var key in update) {
|
||||
var val = update[key];
|
||||
if(typeof val === 'function') {
|
||||
continue; // Skip methods
|
||||
}
|
||||
base[key] = val;
|
||||
}
|
||||
return base;
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
var util = require('util');
|
||||
var Connector = require('../..').Connector;
|
||||
var crypto = require('crypto');
|
||||
|
||||
/**
|
||||
* Initialize the Transient connector against the given data source
|
||||
*
|
||||
* @param {DataSource} dataSource The loopback-datasource-juggler dataSource
|
||||
* @param {Function} [callback] The callback function
|
||||
*/
|
||||
exports.initialize = function initializeDataSource(dataSource, callback) {
|
||||
dataSource.connector = new Transient(null, dataSource.settings);
|
||||
dataSource.connector.connect(callback);
|
||||
};
|
||||
|
||||
exports.Transient = Transient;
|
||||
|
||||
function Transient(m, settings) {
|
||||
settings = settings || {};
|
||||
if (typeof settings.generateId === 'function') {
|
||||
this.generateId = settings.generateId.bind(this);
|
||||
}
|
||||
this.defaultIdType = settings.defaultIdType || String;
|
||||
if (m instanceof Transient) {
|
||||
this.isTransaction = true;
|
||||
this.constructor.super_.call(this, 'transient', settings);
|
||||
this._models = m._models;
|
||||
} else {
|
||||
this.isTransaction = false;
|
||||
this.constructor.super_.call(this, 'transient', settings);
|
||||
}
|
||||
}
|
||||
|
||||
util.inherits(Transient, Connector);
|
||||
|
||||
Transient.prototype.getDefaultIdType = function() {
|
||||
return this.defaultIdType;
|
||||
};
|
||||
|
||||
Transient.prototype.getTypes = function() {
|
||||
return ['db', 'nosql', 'transient'];
|
||||
};
|
||||
|
||||
Transient.prototype.connect = function (callback) {
|
||||
if (this.isTransaction) {
|
||||
this.onTransactionExec = callback;
|
||||
} else {
|
||||
process.nextTick(callback);
|
||||
}
|
||||
};
|
||||
|
||||
Transient.prototype.generateId = function(model, data, idName) {
|
||||
var idType;
|
||||
var props = this._models[model].properties;
|
||||
if (idName) idType = props[idName] && props[idName].type;
|
||||
idType = idType || this.getDefaultIdType();
|
||||
if (idType === Number) {
|
||||
return Math.floor(Math.random() * 10000); // max. 4 digits
|
||||
} else {
|
||||
return crypto.randomBytes(Math.ceil(24/2))
|
||||
.toString('hex') // convert to hexadecimal format
|
||||
.slice(0, 24); // return required number of characters
|
||||
}
|
||||
};
|
||||
|
||||
Transient.prototype.exists = function exists(model, id, callback) {
|
||||
process.nextTick(function () { callback(null, false); }.bind(this));
|
||||
};
|
||||
|
||||
Transient.prototype.find = function find(model, id, callback) {
|
||||
process.nextTick(function () { callback(null, null); }.bind(this));
|
||||
};
|
||||
|
||||
Transient.prototype.all = function all(model, filter, callback) {
|
||||
process.nextTick(function () { callback(null, []); });
|
||||
};
|
||||
|
||||
Transient.prototype.count = function count(model, callback, where) {
|
||||
process.nextTick(function () { callback(null, 0); });
|
||||
};
|
||||
|
||||
Transient.prototype.create = function create(model, data, callback) {
|
||||
var props = this._models[model].properties;
|
||||
var idName = this.idName(model);
|
||||
if (idName && props[idName]) {
|
||||
var id = this.getIdValue(model, data) || this.generateId(model, data, idName);
|
||||
id = (props[idName] && props[idName].type && props[idName].type(id)) || id;
|
||||
this.setIdValue(model, data, id);
|
||||
}
|
||||
this.flush('create', id, callback);
|
||||
};
|
||||
|
||||
Transient.prototype.save = function save(model, data, callback) {
|
||||
this.flush('save', data, callback);
|
||||
};
|
||||
|
||||
Transient.prototype.update =
|
||||
Transient.prototype.updateAll = function updateAll(model, where, data, cb) {
|
||||
var count = 0;
|
||||
this.flush('update', {count: count}, cb);
|
||||
};
|
||||
|
||||
Transient.prototype.updateAttributes = function updateAttributes(model, id, data, cb) {
|
||||
if (!id) {
|
||||
var err = new Error('You must provide an id when updating attributes!');
|
||||
if (cb) {
|
||||
return cb(err);
|
||||
} else {
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
this.setIdValue(model, data, id);
|
||||
this.save(model, data, cb);
|
||||
};
|
||||
|
||||
Transient.prototype.destroy = function destroy(model, id, callback) {
|
||||
this.flush('destroy', null, callback);
|
||||
};
|
||||
|
||||
Transient.prototype.destroyAll = function destroyAll(model, where, callback) {
|
||||
if (!callback && 'function' === typeof where) {
|
||||
callback = where;
|
||||
where = undefined;
|
||||
}
|
||||
this.flush('destroyAll', null, callback);
|
||||
};
|
||||
|
||||
/*!
|
||||
* Flush the cache - noop.
|
||||
* @param {Function} callback
|
||||
*/
|
||||
Transient.prototype.flush = function (action, result, callback) {
|
||||
process.nextTick(function () { callback && callback(null, result); });
|
||||
};
|
||||
|
||||
Transient.prototype.transaction = function () {
|
||||
return new Transient(this);
|
||||
};
|
||||
|
||||
Transient.prototype.exec = function (callback) {
|
||||
this.onTransactionExec();
|
||||
setTimeout(callback, 50);
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -13,13 +13,15 @@
|
|||
},
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"pretest": "jshint .",
|
||||
"test": "mocha"
|
||||
"test": "mocha",
|
||||
"posttest": "jshint ."
|
||||
},
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"async": "^1.0.0",
|
||||
"debug": "^2.2.0"
|
||||
"bluebird": "^3.1.5",
|
||||
"debug": "^2.2.0",
|
||||
"qs": "^6.0.2"
|
||||
},
|
||||
"devDependencies": {
|
||||
"chai": "~2.3.0",
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
var should = require('./init.js');
|
||||
|
||||
var jdb = require('../');
|
||||
var DataSource = jdb.DataSource;
|
||||
|
||||
var ds, Item, Variant;
|
||||
describe('Datasource-specific field types for foreign keys', function () {
|
||||
before(function () {
|
||||
ds = new DataSource('memory');
|
||||
Item = ds.define('Item', {
|
||||
"myProp": {
|
||||
"id": true,
|
||||
"type": "string",
|
||||
"memory": {
|
||||
"dataType": "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
Variant = ds.define('Variant', {}, {
|
||||
relations: {
|
||||
"item": {
|
||||
"type": "belongsTo",
|
||||
"as": "item",
|
||||
"model": "Item",
|
||||
"foreignKey": "myProp"
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('should create foreign key with database-specific field type', function (done) {
|
||||
var VariantDefinition = ds.getModelDefinition('Variant');
|
||||
should.exist(VariantDefinition);
|
||||
should.exist(VariantDefinition.properties.myProp.memory);
|
||||
should.exist(VariantDefinition.properties.myProp.memory.dataType);
|
||||
VariantDefinition.properties.myProp.memory.dataType.should.be.equal("string");
|
||||
done();
|
||||
});
|
||||
})
|
||||
;
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,72 @@
|
|||
// This test written in mocha+should.js
|
||||
var should = require('./init.js');
|
||||
|
||||
var db = getSchema();
|
||||
|
||||
describe('defaults', function () {
|
||||
var Server;
|
||||
|
||||
before(function () {
|
||||
Server = db.define('Server', {
|
||||
host: String,
|
||||
port: {type: Number, default: 80},
|
||||
createdAt: {type: Date, default: '$now'}
|
||||
});
|
||||
});
|
||||
|
||||
it('should apply defaults on new', function () {
|
||||
var s = new Server;
|
||||
s.port.should.equal(80);
|
||||
});
|
||||
|
||||
it('should apply defaults on create', function (done) {
|
||||
Server.create(function (err, s) {
|
||||
s.port.should.equal(80);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should apply defaults on read', function (done) {
|
||||
db.defineProperty('Server', 'host', {
|
||||
type: String,
|
||||
default: 'localhost'
|
||||
});
|
||||
Server.all(function (err, servers) {
|
||||
(new String('localhost')).should.equal(servers[0].host);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should ignore defaults with limited fields', function (done) {
|
||||
Server.create({ host: 'localhost', port: 8080 }, function(err, s) {
|
||||
should.not.exist(err);
|
||||
s.port.should.equal(8080);
|
||||
Server.find({ fields: ['host'] }, function (err, servers) {
|
||||
servers[0].host.should.equal('localhost');
|
||||
servers[0].should.have.property('host');
|
||||
servers[0].should.have.property('port', undefined);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should apply defaults in upsert create', function (done) {
|
||||
Server.upsert({port: 8181 }, function(err, server) {
|
||||
should.not.exist(err);
|
||||
should.exist(server.createdAt);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should preserve defaults in upsert update', function (done) {
|
||||
Server.findOne({}, function(err, server) {
|
||||
Server.upsert({id:server.id, port: 1337 }, function(err, s) {
|
||||
should.not.exist(err);
|
||||
(Number(1337)).should.equal(s.port);
|
||||
server.createdAt.should.eql(s.createdAt);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
|
@ -0,0 +1,604 @@
|
|||
var jdb = require('../');
|
||||
var DataSource = jdb.DataSource;
|
||||
var should = require('./init.js');
|
||||
|
||||
describe('Memory connector with mocked discovery', function() {
|
||||
var ds;
|
||||
|
||||
before(function() {
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
var models = [{type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP'},
|
||||
{type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP'},
|
||||
{type: 'table', name: 'LOCATION', owner: 'STRONGLOOP'}];
|
||||
|
||||
ds.discoverModelDefinitions = function(options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, models);
|
||||
});
|
||||
};
|
||||
|
||||
var modelProperties = [{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'PRODUCT_ID',
|
||||
dataType: 'varchar',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
nullable: 0
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'LOCATION_ID',
|
||||
dataType: 'varchar',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
nullable: 0
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'AVAILABLE',
|
||||
dataType: 'int',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
nullable: 1
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'TOTAL',
|
||||
dataType: 'int',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
nullable: 1
|
||||
}];
|
||||
|
||||
ds.discoverModelProperties = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, modelProperties);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should convert table/column names to camel cases', function(done) {
|
||||
ds.discoverSchemas('INVENTORY', {}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.have.property('STRONGLOOP.INVENTORY');
|
||||
var s = schemas['STRONGLOOP.INVENTORY'];
|
||||
s.name.should.be.eql('Inventory');
|
||||
Object.keys(s.properties).should.be.eql(
|
||||
['productId', 'locationId', 'available', 'total']);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should convert table/column names with custom mapper', function(done) {
|
||||
ds.discoverSchemas('INVENTORY', {
|
||||
nameMapper: function(type, name) {
|
||||
// Convert all names to lower case
|
||||
return name.toLowerCase();
|
||||
}
|
||||
}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.have.property('STRONGLOOP.INVENTORY');
|
||||
var s = schemas['STRONGLOOP.INVENTORY'];
|
||||
s.name.should.be.eql('inventory');
|
||||
Object.keys(s.properties).should.be.eql(
|
||||
['product_id', 'location_id', 'available', 'total']);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should not convert table/column names with null custom mapper',
|
||||
function(done) {
|
||||
ds.discoverSchemas('INVENTORY', {nameMapper: null}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.have.property('STRONGLOOP.INVENTORY');
|
||||
var s = schemas['STRONGLOOP.INVENTORY'];
|
||||
s.name.should.be.eql('INVENTORY');
|
||||
Object.keys(s.properties).should.be.eql(
|
||||
['PRODUCT_ID', 'LOCATION_ID', 'AVAILABLE', 'TOTAL']);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should honor connector\'s discoverSchemas implementation',
|
||||
function(done) {
|
||||
var models = {
|
||||
inventory: {
|
||||
product: {type: 'string'},
|
||||
location: {type: 'string'}
|
||||
}
|
||||
};
|
||||
ds.connector.discoverSchemas = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, models);
|
||||
});
|
||||
};
|
||||
ds.discoverSchemas('INVENTORY', {nameMapper: null}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.be.eql(models);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter',
|
||||
function(done) {
|
||||
var models = {
|
||||
inventory: {
|
||||
product: {type: 'string'},
|
||||
location: {type: 'string'}
|
||||
}
|
||||
};
|
||||
ds.connector.discoverSchemas = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, models);
|
||||
});
|
||||
};
|
||||
|
||||
var options = function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.be.eql(models);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverSchemas('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover schemas using `discoverSchemas` - promise variant',
|
||||
function(done) {
|
||||
ds.connector.discoverSchemas = null;
|
||||
ds.discoverSchemas('INVENTORY', {})
|
||||
.then(function(schemas) {
|
||||
schemas.should.have.property('STRONGLOOP.INVENTORY');
|
||||
|
||||
var s = schemas['STRONGLOOP.INVENTORY'];
|
||||
s.name.should.be.eql('Inventory');
|
||||
|
||||
Object.keys(s.properties).should.be.eql(
|
||||
['productId', 'locationId', 'available', 'total']
|
||||
);
|
||||
done();
|
||||
})
|
||||
.catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverSchema', function(){
|
||||
var models;
|
||||
var schema;
|
||||
before(function() {
|
||||
schema = {
|
||||
name: 'Inventory',
|
||||
options: {
|
||||
idInjection: false,
|
||||
memory: { schema: 'STRONGLOOP', table: 'INVENTORY' }
|
||||
},
|
||||
properties: {
|
||||
available: {
|
||||
length: null,
|
||||
memory: {
|
||||
columnName: 'AVAILABLE',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
dataType: 'int',
|
||||
nullable: 1
|
||||
},
|
||||
precision: 10,
|
||||
required: false,
|
||||
scale: 0,
|
||||
type: undefined
|
||||
},
|
||||
locationId: {
|
||||
length: 20,
|
||||
memory: {
|
||||
columnName: 'LOCATION_ID',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
dataType: 'varchar',
|
||||
nullable: 0
|
||||
},
|
||||
precision: null,
|
||||
required: true,
|
||||
scale: null,
|
||||
type: undefined
|
||||
},
|
||||
productId: {
|
||||
length: 20,
|
||||
memory: {
|
||||
columnName: 'PRODUCT_ID',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
dataType: 'varchar',
|
||||
nullable: 0
|
||||
},
|
||||
precision: null,
|
||||
required: true,
|
||||
scale: null,
|
||||
type: undefined
|
||||
},
|
||||
total: {
|
||||
length: null,
|
||||
memory: {
|
||||
columnName: 'TOTAL',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
dataType: 'int',
|
||||
nullable: 1
|
||||
},
|
||||
precision: 10,
|
||||
required: false,
|
||||
scale: 0,
|
||||
type: undefined
|
||||
}
|
||||
}
|
||||
} ;
|
||||
});
|
||||
|
||||
it('should discover schema using `discoverSchema`', function(done) {
|
||||
ds.discoverSchema('INVENTORY', {}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.be.eql(schema);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
schemas.should.be.eql(schema);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverSchema('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover schema using `discoverSchema` - promise variant', function(done) {
|
||||
ds.discoverSchema('INVENTORY', {})
|
||||
.then(function(schemas) {
|
||||
schemas.should.be.eql(schema);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverModelDefinitions', function(){
|
||||
var ds;
|
||||
before(function(){
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
var models = [{type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP'},
|
||||
{type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP'},
|
||||
{type: 'table', name: 'LOCATION', owner: 'STRONGLOOP'}];
|
||||
|
||||
ds.connector.discoverModelDefinitions = function(options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, models);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should discover model using `discoverModelDefinitions`', function(done) {
|
||||
ds.discoverModelDefinitions({}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
|
||||
var tableNames = schemas.map(function(s) {
|
||||
return s.name;
|
||||
});
|
||||
|
||||
tableNames.should.be.eql(
|
||||
["CUSTOMER", "INVENTORY", "LOCATION"]
|
||||
);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
|
||||
var tableNames = schemas.map(function(s) {
|
||||
return s.name;
|
||||
});
|
||||
|
||||
tableNames.should.be.eql(
|
||||
["CUSTOMER", "INVENTORY", "LOCATION"]
|
||||
);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverModelDefinitions(options);
|
||||
});
|
||||
|
||||
it('should discover model using `discoverModelDefinitions` - promise variant', function(done) {
|
||||
ds.discoverModelDefinitions({})
|
||||
.then(function(schemas) {
|
||||
var tableNames = schemas.map(function(s) {
|
||||
return s.name;
|
||||
});
|
||||
|
||||
tableNames.should.be.eql(
|
||||
["CUSTOMER", "INVENTORY", "LOCATION"]
|
||||
);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverModelProperties', function(){
|
||||
var ds;
|
||||
var modelProperties;
|
||||
before(function(){
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
modelProperties = [{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'PRODUCT_ID',
|
||||
dataType: 'varchar',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
nullable: 0
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'LOCATION_ID',
|
||||
dataType: 'varchar',
|
||||
dataLength: 20,
|
||||
dataPrecision: null,
|
||||
dataScale: null,
|
||||
nullable: 0
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'AVAILABLE',
|
||||
dataType: 'int',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
nullable: 1
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'TOTAL',
|
||||
dataType: 'int',
|
||||
dataLength: null,
|
||||
dataPrecision: 10,
|
||||
dataScale: 0,
|
||||
nullable: 1
|
||||
}];
|
||||
|
||||
ds.connector.discoverModelProperties = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, modelProperties);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
|
||||
schemas.should.be.eql(modelProperties);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverModelProperties('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover model metadata using `discoverModelProperties`', function(done) {
|
||||
ds.discoverModelProperties('INVENTORY', {}, function(err, schemas) {
|
||||
if (err) return done(err);
|
||||
|
||||
schemas.should.be.eql(modelProperties);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should discover model metadata using `discoverModelProperties` - promise variant', function(done) {
|
||||
ds.discoverModelProperties('INVENTORY', {})
|
||||
.then(function(schemas) {
|
||||
schemas.should.be.eql(modelProperties);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverPrimaryKeys', function(){
|
||||
var ds;
|
||||
var modelProperties;
|
||||
before(function(){
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
primaryKeys = [
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'PRODUCT_ID',
|
||||
keySeq: 1,
|
||||
pkName: 'ID_PK'
|
||||
},
|
||||
{
|
||||
owner: 'STRONGLOOP',
|
||||
tableName: 'INVENTORY',
|
||||
columnName: 'LOCATION_ID',
|
||||
keySeq: 2,
|
||||
pkName: 'ID_PK'
|
||||
}];
|
||||
|
||||
ds.connector.discoverPrimaryKeys = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, primaryKeys);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should discover primary key definitions using `discoverPrimaryKeys`', function(done) {
|
||||
ds.discoverPrimaryKeys('INVENTORY', {}, function(err, modelPrimaryKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelPrimaryKeys.should.be.eql(primaryKeys);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, modelPrimaryKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelPrimaryKeys.should.be.eql(primaryKeys);
|
||||
done();
|
||||
};
|
||||
ds.discoverPrimaryKeys('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover primary key definitions using `discoverPrimaryKeys` - promise variant', function(done) {
|
||||
ds.discoverPrimaryKeys('INVENTORY', {})
|
||||
.then(function(modelPrimaryKeys) {
|
||||
modelPrimaryKeys.should.be.eql(primaryKeys);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverForeignKeys', function(){
|
||||
var ds;
|
||||
var modelProperties;
|
||||
before(function(){
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
foreignKeys = [{
|
||||
fkOwner: 'STRONGLOOP',
|
||||
fkName: 'PRODUCT_FK',
|
||||
fkTableName: 'INVENTORY',
|
||||
fkColumnName: 'PRODUCT_ID',
|
||||
keySeq: 1,
|
||||
pkOwner: 'STRONGLOOP',
|
||||
pkName: 'PRODUCT_PK',
|
||||
pkTableName: 'PRODUCT',
|
||||
pkColumnName: 'ID'
|
||||
}];
|
||||
|
||||
ds.connector.discoverForeignKeys = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, foreignKeys);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should discover foreign key definitions using `discoverForeignKeys`', function(done) {
|
||||
ds.discoverForeignKeys('INVENTORY', {}, function(err, modelForeignKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelForeignKeys.should.be.eql(foreignKeys);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, modelForeignKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelForeignKeys.should.be.eql(foreignKeys);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverForeignKeys('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover foreign key definitions using `discoverForeignKeys` - promise variant', function(done) {
|
||||
ds.discoverForeignKeys('INVENTORY', {})
|
||||
.then(function(modelForeignKeys) {
|
||||
modelForeignKeys.should.be.eql(foreignKeys);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('discoverExportedForeignKeys', function(){
|
||||
var ds;
|
||||
var modelProperties;
|
||||
before(function(){
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
|
||||
exportedForeignKeys = [{
|
||||
fkName: 'PRODUCT_FK',
|
||||
fkOwner: 'STRONGLOOP',
|
||||
fkTableName: 'INVENTORY',
|
||||
fkColumnName: 'PRODUCT_ID',
|
||||
keySeq: 1,
|
||||
pkName: 'PRODUCT_PK',
|
||||
pkOwner: 'STRONGLOOP',
|
||||
pkTableName: 'PRODUCT',
|
||||
pkColumnName: 'ID'
|
||||
}];
|
||||
|
||||
ds.connector.discoverExportedForeignKeys = function(modelName, options, cb) {
|
||||
process.nextTick(function() {
|
||||
cb(null, exportedForeignKeys);
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
it('should discover foreign key definitions using `discoverExportedForeignKeys`', function(done) {
|
||||
ds.discoverExportedForeignKeys('INVENTORY', {}, function(err, modelForeignKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelForeignKeys.should.be.eql(exportedForeignKeys);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should callback function, passed as options parameter', function(done) {
|
||||
var options = function(err, modelForeignKeys) {
|
||||
if (err) return done(err);
|
||||
|
||||
modelForeignKeys.should.be.eql(exportedForeignKeys);
|
||||
done();
|
||||
};
|
||||
|
||||
ds.discoverExportedForeignKeys('INVENTORY', options);
|
||||
});
|
||||
|
||||
it('should discover foreign key definitions using `discoverExportedForeignKeys` - promise variant', function(done) {
|
||||
ds.discoverExportedForeignKeys('INVENTORY', {})
|
||||
.then(function(modelForeignKeys) {
|
||||
modelForeignKeys.should.be.eql(exportedForeignKeys);
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
module.exports = require('should');
|
||||
|
||||
/*
|
||||
if (!process.env.TRAVIS) {
|
||||
if (typeof __cov === 'undefined') {
|
||||
process.on('exit', function () {
|
||||
require('semicov').report();
|
||||
});
|
||||
}
|
||||
|
||||
require('semicov').init('lib');
|
||||
}
|
||||
*/
|
||||
|
||||
var ModelBuilder = require('loopback-model/lib/model-builder').ModelBuilder;
|
||||
var Schema = require('../').Schema;
|
||||
|
||||
if (!('getSchema' in global)) {
|
||||
global.getSchema = function (connector, settings) {
|
||||
return new Schema(connector || 'memory', settings);
|
||||
};
|
||||
}
|
||||
|
||||
if (!('getModelBuilder' in global)) {
|
||||
global.getModelBuilder = function () {
|
||||
return new ModelBuilder();
|
||||
};
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
var metadata = require('../package.json');
|
||||
var project = require('..');
|
||||
var should = require('./init.js');
|
||||
|
||||
describe('juggler', function() {
|
||||
it('should expose a version number', function() {
|
||||
project.version.should.equal(metadata.version);
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
{
|
||||
"ids": {
|
||||
"User": 4
|
||||
},
|
||||
"models": {
|
||||
"User": {
|
||||
"2": "{\"name\":\"John1\",\"id\":2}",
|
||||
"3": "{\"name\":\"John3\",\"id\":3}"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,987 @@
|
|||
var jdb = require('../');
|
||||
var DataSource = jdb.DataSource;
|
||||
var path = require('path');
|
||||
var fs = require('fs');
|
||||
var assert = require('assert');
|
||||
var async = require('async');
|
||||
var should = require('./init.js');
|
||||
var Memory = require('../lib/connectors/memory').Memory;
|
||||
|
||||
describe('Memory connector', function() {
|
||||
var file = path.join(__dirname, 'memory.json');
|
||||
|
||||
function readModels(done) {
|
||||
fs.readFile(file, function(err, data) {
|
||||
var json = JSON.parse(data.toString());
|
||||
assert(json.models);
|
||||
assert(json.ids.User);
|
||||
done(err, json);
|
||||
});
|
||||
}
|
||||
|
||||
before(function(done) {
|
||||
fs.unlink(file, function(err) {
|
||||
if (!err || err.code === 'ENOENT') {
|
||||
done();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('with file', function() {
|
||||
function createUserModel() {
|
||||
var ds = new DataSource({
|
||||
connector: 'memory',
|
||||
file: file
|
||||
});
|
||||
|
||||
var User = ds.createModel('User', {
|
||||
id: {
|
||||
type: Number,
|
||||
id: true,
|
||||
generated: true
|
||||
},
|
||||
name: String,
|
||||
bio: String,
|
||||
approved: Boolean,
|
||||
joinedAt: Date,
|
||||
age: Number
|
||||
});
|
||||
return User;
|
||||
}
|
||||
|
||||
var User;
|
||||
var ids = [];
|
||||
|
||||
before(function() {
|
||||
User = createUserModel();
|
||||
});
|
||||
|
||||
it('should persist create', function(done) {
|
||||
var count = 0;
|
||||
async.eachSeries(['John1', 'John2', 'John3'], function(item, cb) {
|
||||
User.create({name: item}, function(err, result) {
|
||||
ids.push(result.id);
|
||||
count++;
|
||||
readModels(function(err, json) {
|
||||
assert.equal(Object.keys(json.models.User).length, count);
|
||||
cb(err);
|
||||
});
|
||||
});
|
||||
}, done);
|
||||
});
|
||||
|
||||
it('should persist delete', function(done) {
|
||||
// Now try to delete one
|
||||
User.deleteById(ids[0], function(err) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
readModels(function(err, json) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
assert.equal(Object.keys(json.models.User).length, 2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should persist upsert', function(done) {
|
||||
User.upsert({id: ids[1], name: 'John'}, function(err, result) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
readModels(function(err, json) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
assert.equal(Object.keys(json.models.User).length, 2);
|
||||
var user = JSON.parse(json.models.User[ids[1]]);
|
||||
assert.equal(user.name, 'John');
|
||||
assert(user.id === ids[1]);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should persist update', function(done) {
|
||||
User.update({id: ids[1]}, {name: 'John1'},
|
||||
function(err, result) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
readModels(function(err, json) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
assert.equal(Object.keys(json.models.User).length, 2);
|
||||
var user = JSON.parse(json.models.User[ids[1]]);
|
||||
assert.equal(user.name, 'John1');
|
||||
assert(user.id === ids[1]);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// The saved memory.json from previous test should be loaded
|
||||
it('should load from the json file', function(done) {
|
||||
User.find(function(err, users) {
|
||||
// There should be 2 records
|
||||
assert.equal(users.length, 2);
|
||||
done(err);
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
describe('Query for memory connector', function() {
|
||||
var ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
|
||||
var User = ds.define('User', {
|
||||
seq: {type: Number, index: true},
|
||||
name: {type: String, index: true, sort: true},
|
||||
email: {type: String, index: true},
|
||||
birthday: {type: Date, index: true},
|
||||
role: {type: String, index: true},
|
||||
order: {type: Number, index: true, sort: true},
|
||||
vip: {type: Boolean},
|
||||
address: {
|
||||
street: String,
|
||||
city: String,
|
||||
state: String,
|
||||
zipCode: String
|
||||
},
|
||||
friends: [
|
||||
{
|
||||
name: String
|
||||
}
|
||||
]
|
||||
});
|
||||
|
||||
before(seed);
|
||||
it('should allow to find using like', function(done) {
|
||||
User.find({where: {name: {like: '%St%'}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should allow to find using like with regexp', function(done) {
|
||||
User.find({where: {name: {like: /.*St.*/}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support like for no match', function(done) {
|
||||
User.find({where: {name: {like: 'M%XY'}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should allow to find using nlike', function(done) {
|
||||
User.find({where: {name: {nlike: '%St%'}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 4);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should allow to find using nlike with regexp', function(done) {
|
||||
User.find({where: {name: {nlike: /.*St.*/}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 4);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support nlike for no match', function(done) {
|
||||
User.find({where: {name: {nlike: 'M%XY'}}}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts.should.have.property('length', 6);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the like value is not string or regexp', function(done) {
|
||||
User.find({where: {name: {like: 123}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the nlike value is not string or regexp', function(done) {
|
||||
User.find({where: {name: {nlike: 123}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the inq value is not an array', function(done) {
|
||||
User.find({where: {name: {inq: '12'}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the nin value is not an array', function(done) {
|
||||
User.find({where: {name: {nin: '12'}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the between value is not an array', function(done) {
|
||||
User.find({where: {name: {between: '12'}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if the between value is not an array of length 2', function(done) {
|
||||
User.find({where: {name: {between: ['12']}}}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 5 users from the db', function(done) {
|
||||
User.find({where: {seq: {between: [1,5]}}}, function(err, users) {
|
||||
should(users.length).be.equal(5);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 1 user (Lennon) from the db', function(done) {
|
||||
User.find({where: {birthday: {between: [new Date(1970,0),new Date(1990,0)]}}},
|
||||
function(err, users) {
|
||||
should(users.length).be.equal(1);
|
||||
should(users[0].name).be.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 2 users from the db', function(done) {
|
||||
User.find({where: {birthday: {between: [new Date(1940,0),new Date(1990,0)]}}},
|
||||
function(err, users) {
|
||||
should(users.length).be.equal(2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 2 users using implied and', function(done) {
|
||||
User.find({where: {role:'lead', vip:true}}, function(err, users) {
|
||||
should(users.length).be.equal(2);
|
||||
should(users[0].name).be.equal('John Lennon');
|
||||
should(users[1].name).be.equal('Paul McCartney');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 2 users using implied and & and', function(done) {
|
||||
User.find({where: { name: 'John Lennon',and: [{role:'lead'}, {vip:true}]}}, function(err, users) {
|
||||
should(users.length).be.equal(1);
|
||||
should(users[0].name).be.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 2 users using date range', function(done) {
|
||||
User.find({where: {birthday: {between:
|
||||
[new Date(1940, 0).toISOString(), new Date(1990, 0).toISOString()]}}},
|
||||
function(err, users) {
|
||||
should(users.length).be.equal(2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 0 user from the db', function(done) {
|
||||
User.find({where: {birthday: {between: [new Date(1990,0), Date.now()]}}},
|
||||
function(err, users) {
|
||||
should(users.length).be.equal(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 2 users matching over array values', function (done) {
|
||||
User.find({
|
||||
where: {
|
||||
children: {
|
||||
regexp: /an/
|
||||
}
|
||||
}
|
||||
}, function (err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(2);
|
||||
users[0].name.should.be.equal('John Lennon');
|
||||
users[1].name.should.be.equal('George Harrison');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 1 users matching over array values', function (done) {
|
||||
User.find({
|
||||
where: {
|
||||
children: 'Dhani'
|
||||
}
|
||||
}, function (err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(1);
|
||||
users[0].name.should.be.equal('George Harrison');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should successfully extract 5 users matching a neq filter over array values', function (done) {
|
||||
User.find({
|
||||
where: {
|
||||
'children': {neq: 'Dhani'}
|
||||
}
|
||||
}, function (err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(5);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should count using date string', function(done) {
|
||||
User.count({birthday: {lt: new Date(1990,0).toISOString()}},
|
||||
function(err, count) {
|
||||
should(count).be.equal(2);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support order with multiple fields', function(done) {
|
||||
User.find({order: 'vip ASC, seq DESC'}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
posts[0].seq.should.be.eql(4);
|
||||
posts[1].seq.should.be.eql(3);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should sort undefined values to the end when ordered DESC', function(done) {
|
||||
User.find({order: 'vip ASC, order DESC'}, function(err, posts) {
|
||||
should.not.exist(err);
|
||||
|
||||
posts[4].seq.should.be.eql(1);
|
||||
posts[5].seq.should.be.eql(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw if order has wrong direction', function(done) {
|
||||
User.find({order: 'seq ABC'}, function(err, posts) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support neq operator for number', function(done) {
|
||||
User.find({where: {seq: {neq: 4}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(5);
|
||||
for (var i = 0; i < users.length; i++) {
|
||||
users[i].seq.should.not.be.equal(4);
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support neq operator for string', function(done) {
|
||||
User.find({where: {role: {neq: 'lead'}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(4);
|
||||
for (var i = 0; i < users.length; i++) {
|
||||
if (users[i].role) {
|
||||
users[i].role.not.be.equal('lead');
|
||||
}
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support neq operator for null', function(done) {
|
||||
User.find({where: {role: {neq: null}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(2);
|
||||
for (var i = 0; i < users.length; i++) {
|
||||
should.exist(users[i].role);
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should work when a regex is provided without the regexp operator',
|
||||
function(done) {
|
||||
User.find({where: {name: /John.*/i}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.equal(1);
|
||||
users[0].name.should.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support the regexp operator with regex strings', function(done) {
|
||||
User.find({where: {name: {regexp: '^J'}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.equal(1);
|
||||
users[0].name.should.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support the regexp operator with regex literals', function(done) {
|
||||
User.find({where: {name: {regexp: /^J/}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.equal(1);
|
||||
users[0].name.should.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support the regexp operator with regex objects', function(done) {
|
||||
User.find({where: {name: {regexp: new RegExp(/^J/)}}}, function(err,
|
||||
users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.equal(1);
|
||||
users[0].name.should.equal('John Lennon');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support nested property in query', function(done) {
|
||||
User.find({where: {'address.city': 'San Jose'}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(1);
|
||||
for (var i = 0; i < users.length; i++) {
|
||||
users[i].address.city.should.be.eql('San Jose');
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support nested property with regex over arrays in query', function(done) {
|
||||
User.find({where: {'friends.name': {regexp: /^Ringo/}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(2);
|
||||
users[0].name.should.be.equal('John Lennon');
|
||||
users[1].name.should.be.equal('Paul McCartney');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support nested property with gt in query', function(done) {
|
||||
User.find({where: {'address.city': {gt: 'San'}}}, function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(2);
|
||||
for (var i = 0; i < users.length; i++) {
|
||||
users[i].address.state.should.be.eql('CA');
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should support nested property for order in query', function(done) {
|
||||
User.find({where: {'address.state': 'CA'}, order: 'address.city DESC'},
|
||||
function(err, users) {
|
||||
should.not.exist(err);
|
||||
users.length.should.be.equal(2);
|
||||
users[0].address.city.should.be.eql('San Mateo');
|
||||
users[1].address.city.should.be.eql('San Jose');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should deserialize values after saving in upsert', function(done) {
|
||||
User.findOne({where: {seq: 1}}, function(err, paul) {
|
||||
User.updateOrCreate({id: paul.id, name: 'Sir Paul McCartney'},
|
||||
function(err, sirpaul) {
|
||||
should.not.exist(err);
|
||||
sirpaul.birthday.should.be.instanceOf(Date);
|
||||
sirpaul.order.should.be.instanceOf(Number);
|
||||
sirpaul.vip.should.be.instanceOf(Boolean);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function seed(done) {
|
||||
var beatles = [
|
||||
{
|
||||
seq: 0,
|
||||
name: 'John Lennon',
|
||||
email: 'john@b3atl3s.co.uk',
|
||||
role: 'lead',
|
||||
birthday: new Date('1980-12-08'),
|
||||
vip: true,
|
||||
address: {
|
||||
street: '123 A St',
|
||||
city: 'San Jose',
|
||||
state: 'CA',
|
||||
zipCode: '95131'
|
||||
},
|
||||
friends: [
|
||||
{ name: 'Paul McCartney' },
|
||||
{ name: 'George Harrison' },
|
||||
{ name: 'Ringo Starr' },
|
||||
],
|
||||
children: ['Sean', 'Julian']
|
||||
},
|
||||
{
|
||||
seq: 1,
|
||||
name: 'Paul McCartney',
|
||||
email: 'paul@b3atl3s.co.uk',
|
||||
role: 'lead',
|
||||
birthday: new Date('1942-06-18'),
|
||||
order: 1,
|
||||
vip: true,
|
||||
address: {
|
||||
street: '456 B St',
|
||||
city: 'San Mateo',
|
||||
state: 'CA',
|
||||
zipCode: '94065'
|
||||
},
|
||||
friends: [
|
||||
{ name: 'John Lennon' },
|
||||
{ name: 'George Harrison' },
|
||||
{ name: 'Ringo Starr' },
|
||||
],
|
||||
children: ['Stella', 'Mary', 'Heather', 'Beatrice', 'James']
|
||||
},
|
||||
{seq: 2, name: 'George Harrison', order: 5, vip: false, children: ['Dhani']},
|
||||
{seq: 3, name: 'Ringo Starr', order: 6, vip: false},
|
||||
{seq: 4, name: 'Pete Best', order: 4, children: []},
|
||||
{seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true}
|
||||
];
|
||||
|
||||
async.series([
|
||||
User.destroyAll.bind(User),
|
||||
function(cb) {
|
||||
async.each(beatles, User.create.bind(User), cb);
|
||||
}
|
||||
], done);
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
it('should use collection setting', function(done) {
|
||||
var ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
|
||||
var Product = ds.createModel('Product', {
|
||||
name: String
|
||||
});
|
||||
|
||||
var Tool = ds.createModel('Tool', {
|
||||
name: String
|
||||
}, {memory: {collection: 'Product'}});
|
||||
|
||||
var Widget = ds.createModel('Widget', {
|
||||
name: String
|
||||
}, {memory: {collection: 'Product'}});
|
||||
|
||||
ds.connector.getCollection('Tool').should.equal('Product');
|
||||
ds.connector.getCollection('Widget').should.equal('Product');
|
||||
|
||||
async.series([
|
||||
function(next) {
|
||||
Tool.create({ name: 'Tool A' }, next);
|
||||
},
|
||||
function(next) {
|
||||
Tool.create({ name: 'Tool B' }, next);
|
||||
},
|
||||
function(next) {
|
||||
Widget.create({ name: 'Widget A' }, next);
|
||||
}
|
||||
], function(err) {
|
||||
Product.find(function(err, products) {
|
||||
should.not.exist(err);
|
||||
products.should.have.length(3);
|
||||
products[0].toObject().should.eql({ name: 'Tool A', id: 1 });
|
||||
products[1].toObject().should.eql({ name: 'Tool B', id: 2 });
|
||||
products[2].toObject().should.eql({ name: 'Widget A', id: 3 });
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('automigrate', function() {
|
||||
var ds;
|
||||
beforeEach(function() {
|
||||
ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
|
||||
ds.createModel('m1', {
|
||||
name: String
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate all models', function(done) {
|
||||
ds.automigrate(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate all models - promise variant', function(done) {
|
||||
ds.automigrate()
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate one model', function(done) {
|
||||
ds.automigrate('m1', function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate one model - promise variant', function(done) {
|
||||
ds.automigrate('m1')
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate one or more models in an array', function(done) {
|
||||
ds.automigrate(['m1'], function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate one or more models in an array - promise variant', function(done) {
|
||||
ds.automigrate(['m1'])
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate reports errors for models not attached', function(done) {
|
||||
ds.automigrate(['m1', 'm2'], function(err) {
|
||||
err.should.be.an.instanceOf(Error);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate reports errors for models not attached - promise variant', function(done) {
|
||||
ds.automigrate(['m1', 'm2'])
|
||||
.then(function(){
|
||||
done(new Error('automigrate() should have failed'));
|
||||
})
|
||||
.catch(function(err){
|
||||
err.should.be.an.instanceOf(Error);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('findOrCreate', function() {
|
||||
var ds, Cars;
|
||||
before(function() {
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
Cars = ds.define('Cars', {
|
||||
color: String
|
||||
});
|
||||
});
|
||||
|
||||
it('should create a specific object once and in the subsequent calls it should find it', function(done) {
|
||||
var creationNum = 0;
|
||||
async.times(100, function(n, next) {
|
||||
var initialData = {color: 'white'};
|
||||
var query = {'where': initialData};
|
||||
Cars.findOrCreate(query, initialData, function(err, car, created) {
|
||||
if (created) creationNum++;
|
||||
next(err, car);
|
||||
});
|
||||
}, function(err, cars) {
|
||||
if (err) done(err);
|
||||
Cars.find(function(err, data) {
|
||||
if (err) done(err);
|
||||
data.length.should.equal(1);
|
||||
data[0].color.should.equal('white');
|
||||
creationNum.should.equal(1);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe('automigrate when NO models are attached', function() {
|
||||
var ds;
|
||||
beforeEach(function() {
|
||||
ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
});
|
||||
|
||||
it('automigrate does NOT report error when NO models are attached', function(done) {
|
||||
ds.automigrate(function(err) {
|
||||
done();
|
||||
})
|
||||
});
|
||||
|
||||
it('automigrate does NOT report error when NO models are attached - promise variant', function(done) {
|
||||
ds.automigrate()
|
||||
.then(done)
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('With mocked autoupdate', function() {
|
||||
var ds, model;
|
||||
beforeEach(function() {
|
||||
ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
|
||||
ds.connector.autoupdate = function(models, cb) {
|
||||
process.nextTick(cb);
|
||||
};
|
||||
|
||||
model = ds.createModel('m1', {
|
||||
name: String
|
||||
});
|
||||
|
||||
ds.automigrate();
|
||||
|
||||
ds.createModel('m1', {
|
||||
name: String,
|
||||
address: String
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates all models', function(done) {
|
||||
ds.autoupdate(function(err, result){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates all models - promise variant', function(done) {
|
||||
ds.autoupdate()
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates one model', function(done) {
|
||||
ds.autoupdate('m1', function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates one model - promise variant', function(done) {
|
||||
ds.autoupdate('m1')
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates one or more models in an array', function(done) {
|
||||
ds.autoupdate(['m1'], function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdates one or more models in an array - promise variant', function(done) {
|
||||
ds.autoupdate(['m1'])
|
||||
.then(function(result) {
|
||||
done();
|
||||
})
|
||||
.catch(function(err){
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdate reports errors for models not attached', function(done) {
|
||||
ds.autoupdate(['m1', 'm2'], function(err) {
|
||||
err.should.be.an.instanceOf(Error);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('autoupdate reports errors for models not attached - promise variant', function(done) {
|
||||
ds.autoupdate(['m1', 'm2'])
|
||||
.then(function(){
|
||||
done(new Error('automigrate() should have failed'));
|
||||
})
|
||||
.catch(function(err){
|
||||
err.should.be.an.instanceOf(Error);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Optimized connector', function() {
|
||||
var ds = new DataSource({ connector: Memory });
|
||||
|
||||
// optimized methods
|
||||
ds.connector.findOrCreate = function (model, query, data, callback) {
|
||||
this.all(model, query, {}, function (err, list) {
|
||||
if (err || (list && list[0])) return callback(err, list && list[0], false);
|
||||
this.create(model, data, {}, function (err) {
|
||||
callback(err, data, true);
|
||||
});
|
||||
}.bind(this));
|
||||
};
|
||||
|
||||
require('loopback-model-persistence/test/persistence-hooks.suite')(ds, should);
|
||||
});
|
||||
|
||||
describe('Unoptimized connector', function() {
|
||||
var ds = new DataSource({ connector: Memory });
|
||||
// disable optimized methods
|
||||
ds.connector.updateOrCreate = false;
|
||||
ds.connector.findOrCreate = false;
|
||||
|
||||
require('loopback-model-persistence/test/persistence-hooks.suite')(ds, should);
|
||||
});
|
||||
|
||||
describe('Memory connector with options', function() {
|
||||
var ds, savedOptions = {}, Post;
|
||||
|
||||
before(function() {
|
||||
ds = new DataSource({connector: 'memory'});
|
||||
ds.connector.create = function(model, data, options, cb) {
|
||||
savedOptions.create = options;
|
||||
process.nextTick(function() {
|
||||
cb(null, 1);
|
||||
});
|
||||
};
|
||||
|
||||
ds.connector.update = function(model, where, data, options, cb) {
|
||||
savedOptions.update = options;
|
||||
process.nextTick(function() {
|
||||
cb(null, {count: 1});
|
||||
});
|
||||
};
|
||||
|
||||
ds.connector.all = function(model, filter, options, cb) {
|
||||
savedOptions.find = options;
|
||||
process.nextTick(function() {
|
||||
cb(null, [{title: 't1', content: 'c1'}]);
|
||||
});
|
||||
};
|
||||
|
||||
Post = ds.define('Post', {
|
||||
title: String,
|
||||
content: String
|
||||
});
|
||||
});
|
||||
|
||||
it('should receive options from the find method', function(done) {
|
||||
var opts = {transaction: 'tx1'};
|
||||
Post.find({where: {title: 't1'}}, opts, function(err, p) {
|
||||
savedOptions.find.should.be.eql(opts);
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('should receive options from the find method', function(done) {
|
||||
var opts = {transaction: 'tx2'};
|
||||
Post.find({}, opts, function(err, p) {
|
||||
savedOptions.find.should.be.eql(opts);
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('should treat first object arg as filter for find', function(done) {
|
||||
var filter = {title: 't1'};
|
||||
Post.find(filter, function(err, p) {
|
||||
savedOptions.find.should.be.eql({});
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('should receive options from the create method', function(done) {
|
||||
var opts = {transaction: 'tx3'};
|
||||
Post.create({title: 't1', content: 'c1'}, opts, function(err, p) {
|
||||
savedOptions.create.should.be.eql(opts);
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('should receive options from the update method', function(done) {
|
||||
var opts = {transaction: 'tx4'};
|
||||
Post.update({title: 't1'}, {content: 'c1 --> c2'},
|
||||
opts, function(err, p) {
|
||||
savedOptions.update.should.be.eql(opts);
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('Memory connector with observers', function() {
|
||||
var ds = new DataSource({
|
||||
connector: 'memory'
|
||||
});
|
||||
|
||||
it('should have observer mixed into the connector', function() {
|
||||
ds.connector.observe.should.be.a.function;
|
||||
ds.connector.notifyObserversOf.should.be.a.function;
|
||||
});
|
||||
|
||||
it('should notify observers', function(done) {
|
||||
var events = [];
|
||||
ds.connector.execute = function(command, params, options, cb) {
|
||||
var self = this;
|
||||
var context = {command: command, params: params, options: options};
|
||||
self.notifyObserversOf('before execute', context, function(err) {
|
||||
process.nextTick(function() {
|
||||
if (err) return cb(err);
|
||||
events.push('execute');
|
||||
self.notifyObserversOf('after execute', context, function(err) {
|
||||
cb(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
ds.connector.observe('before execute', function(context, next) {
|
||||
events.push('before execute');
|
||||
next();
|
||||
});
|
||||
|
||||
ds.connector.observe('after execute', function(context, next) {
|
||||
events.push('after execute');
|
||||
next();
|
||||
});
|
||||
|
||||
ds.connector.execute('test', [1, 2], {x: 2}, function(err) {
|
||||
if (err) return done(err);
|
||||
events.should.eql(['before execute', 'execute', 'after execute']);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
// This test written in mocha+should.js
|
||||
var should = require('./init.js');
|
||||
|
||||
var db = getSchema(), slave = getSchema(), Model, SlaveModel;
|
||||
|
||||
describe('dataSource', function () {
|
||||
|
||||
it('should define Model', function () {
|
||||
Model = db.define('Model');
|
||||
Model.dataSource.should.eql(db);
|
||||
var m = new Model;
|
||||
m.getDataSource().should.eql(db);
|
||||
});
|
||||
|
||||
it('should clone existing model', function () {
|
||||
SlaveModel = slave.copyModel(Model);
|
||||
SlaveModel.dataSource.should.equal(slave);
|
||||
slave.should.not.equal(db);
|
||||
var sm = new SlaveModel;
|
||||
sm.should.be.instanceOf(Model);
|
||||
sm.getDataSource().should.not.equal(db);
|
||||
sm.getDataSource().should.equal(slave);
|
||||
});
|
||||
|
||||
it('should automigrate', function (done) {
|
||||
db.automigrate(done);
|
||||
});
|
||||
|
||||
it('should create transaction', function (done) {
|
||||
var tr = db.transaction();
|
||||
tr.connected.should.be.false;
|
||||
tr.connecting.should.be.false;
|
||||
var called = false;
|
||||
tr.models.Model.create(Array(3), function () {
|
||||
called = true;
|
||||
});
|
||||
tr.connected.should.be.false;
|
||||
tr.connecting.should.be.true;
|
||||
|
||||
db.models.Model.count(function (err, c) {
|
||||
should.not.exist(err);
|
||||
should.exist(c);
|
||||
c.should.equal(0);
|
||||
called.should.be.false;
|
||||
tr.exec(function () {
|
||||
setTimeout(function () {
|
||||
called.should.be.true;
|
||||
db.models.Model.count(function (err, c) {
|
||||
c.should.equal(3);
|
||||
done();
|
||||
});
|
||||
}, 100);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
if (!process.env.TRAVIS) {
|
||||
var semicov = require('semicov');
|
||||
semicov.init('lib', 'LoopbackData');
|
||||
process.on('exit', semicov.report);
|
||||
}
|
||||
*/
|
||||
|
||||
var group_name = false, EXT_EXP;
|
||||
function it(should, test_case) {
|
||||
check_external_exports();
|
||||
if (group_name) {
|
||||
EXT_EXP[group_name][should] = test_case;
|
||||
} else {
|
||||
EXT_EXP[should] = test_case;
|
||||
}
|
||||
}
|
||||
|
||||
global.it = it;
|
||||
|
||||
function context(name, tests) {
|
||||
check_external_exports();
|
||||
EXT_EXP[name] = {};
|
||||
group_name = name;
|
||||
tests({
|
||||
before: function (f) {
|
||||
it('setUp', f);
|
||||
},
|
||||
after: function (f) {
|
||||
it('tearDown', f);
|
||||
}
|
||||
});
|
||||
group_name = false;
|
||||
}
|
||||
|
||||
global.context = context;
|
||||
|
||||
exports.init = function init(external_exports) {
|
||||
EXT_EXP = external_exports;
|
||||
if (external_exports.done) {
|
||||
external_exports.done();
|
||||
}
|
||||
};
|
||||
|
||||
function check_external_exports() {
|
||||
if (!EXT_EXP) throw new Error(
|
||||
'Before run this, please ensure that ' +
|
||||
'require("spec_helper").init(exports); called');
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
var jdb = require('../');
|
||||
var DataSource = jdb.DataSource;
|
||||
var assert = require('assert');
|
||||
var async = require('async');
|
||||
var should = require('./init.js');
|
||||
|
||||
var db, TransientModel, Person, Widget, Item;
|
||||
|
||||
var getTransientDataSource = function(settings) {
|
||||
return new DataSource('transient', settings);
|
||||
};
|
||||
|
||||
describe('Transient connector', function () {
|
||||
|
||||
before(function () {
|
||||
db = getTransientDataSource();
|
||||
TransientModel = db.define('TransientModel', {}, { idInjection: false });
|
||||
|
||||
Person = TransientModel.extend('Person', {name: String});
|
||||
Person.attachTo(db);
|
||||
|
||||
Widget = db.define('Widget', {name: String});
|
||||
Item = db.define('Item', {
|
||||
id: {type: Number, id: true}, name: String
|
||||
});
|
||||
});
|
||||
|
||||
it('should respect idInjection being false', function(done) {
|
||||
should.not.exist(Person.definition.properties.id);
|
||||
should.exist(Person.definition.properties.name);
|
||||
|
||||
Person.create({ name: 'Wilma' }, function(err, inst) {
|
||||
should.not.exist(err);
|
||||
inst.toObject().should.eql({ name: 'Wilma' });
|
||||
|
||||
Person.count(function(err, count) {
|
||||
should.not.exist(err);
|
||||
count.should.equal(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should generate a random string id', function(done) {
|
||||
should.exist(Widget.definition.properties.id);
|
||||
should.exist(Widget.definition.properties.name);
|
||||
|
||||
Widget.definition.properties.id.type.should.equal(String);
|
||||
|
||||
Widget.create({ name: 'Thing' }, function(err, inst) {
|
||||
should.not.exist(err);
|
||||
inst.id.should.match(/^[0-9a-fA-F]{24}$/);
|
||||
inst.name.should.equal('Thing');
|
||||
|
||||
Widget.findById(inst.id, function(err, widget) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(widget);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should generate a random number id', function(done) {
|
||||
should.exist(Item.definition.properties.id);
|
||||
should.exist(Item.definition.properties.name);
|
||||
|
||||
Item.definition.properties.id.type.should.equal(Number);
|
||||
|
||||
Item.create({ name: 'Example' }, function(err, inst) {
|
||||
should.not.exist(err);
|
||||
inst.name.should.equal('Example');
|
||||
|
||||
Item.count(function(err, count) {
|
||||
should.not.exist(err);
|
||||
count.should.equal(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
Loading…
Reference in New Issue