reheat/old_test/reheat/model/prototype/index.test.js

A red hot Node.js ORM for RethinkDB.

/*jshint loopfunc:true*/

var prototype = require('../../../../../build/instrument/lib/model/prototype'),
	errors = require('../../../../../build/instrument/lib/support/errors'),
	utils = require('../../../../../build/instrument/lib/support/utils'),
	support = require('../../../../support/support'),
	sinon = require('sinon');

exports.index = {
	escape: function (test) {
		test.expect(10);

		var instance = {
			attributes: {
				name: '<tag>'
			},
			escape: prototype.escape,
			get: prototype.get
		};

		var escaped;
		try {
			escaped = instance.escape('name');
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.equal(escaped, '&lt;tag&gt;');

		for (var i = 0; i < support.TYPES_EXCEPT_STRING.length; i++) {
			test.throws(
				function () {
					instance.escape(support.TYPES_EXCEPT_STRING[i]);
				},
				errors.IllegalArgumentError
			);
		}

		test.done();
	},
	toJSON: function (test) {
		test.expect(1);

		var instance = {
			attributes: {
				name: 'John'
			},
			toJSON: prototype.toJSON
		};

		var json;
		try {
			json = instance.toJSON();
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.deepEqual(json, {
			name: 'John'
		});

		test.done();
	},
	functions: function (test) {
		test.expect(1);

		var instance = {
			attributes: {
				name: 'John'
			},
			toJSON: prototype.toJSON,
			functions: prototype.functions
		};

		var functions;
		try {
			functions = instance.functions();
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.deepEqual(functions, [
			'functions',
			'toJSON'
		]);

		test.done();
	},
	get: function (test) {
		test.expect(11);

		var instance = {
			attributes: {
				name: 'John',
				address: {
					state: 'NY'
				}
			},
			get: prototype.get
		};

		var res;
		try {
			res = instance.get('name');
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.deepEqual(res, 'John');
		try {
			res = instance.get('address.state');
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.deepEqual(res, 'NY');

		for (var i = 0; i < support.TYPES_EXCEPT_STRING.length; i++) {
			test.throws(
				function () {
					instance.get(support.TYPES_EXCEPT_STRING[i]);
				},
				errors.IllegalArgumentError
			);
		}

		test.done();
	},
	clone: function (test) {
		test.expect(3);

		function constructor(attrs) {
			return {
				attributes: utils.clone(attrs),
				constructor: constructor,
				clone: prototype.clone
			};
		}

		var instance = {
			attributes: {
				name: 'John',
				address: {
					state: 'NY'
				},
				'key.with.dots': 'test'
			},
			constructor: constructor,
			clone: prototype.clone
		};

		var clone;
		try {
			clone = instance.clone();
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.deepEqual(clone, {
			attributes: {
				name: 'John',
				address: {
					state: 'NY'
				},
				'key.with.dots': 'test'
			},
			constructor: constructor,
			clone: prototype.clone
		});
		clone.attributes.name = 'Sally';
		test.deepEqual(instance, {
			attributes: {
				name: 'John',
				address: {
					state: 'NY'
				},
				'key.with.dots': 'test'
			},
			constructor: constructor,
			clone: prototype.clone
		});
		test.deepEqual(clone, {
			attributes: {
				name: 'Sally',
				address: {
					state: 'NY'
				},
				'key.with.dots': 'test'
			},
			constructor: constructor,
			clone: prototype.clone
		});

		test.done();
	},
	isNew: function (test) {
		test.expect(2);

		var instance = {
			attributes: {
				_id: 5
			},
			constructor: {
				idAttribute: '_id'
			},
			isNew: prototype.isNew
		};

		var res;
		try {
			res = instance.isNew();
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.ok(!res);

		instance = {
			attributes: {
				name: 'John'
			},
			constructor: {
				idAttribute: '_id'
			},
			isNew: prototype.isNew
		};

		try {
			res = instance.isNew();
		} catch (err) {
			support.fail('Should not reach this');
		}
		test.ok(res);

		test.done();
	},
	lifecycle: function (test) {
		test.expect(8);

		var instance = {
			beforeValidate: prototype.beforeValidate,
			afterValidate: prototype.afterValidate,
			beforeCreate: prototype.beforeCreate,
			afterCreate: prototype.afterCreate,
			beforeUpdate: prototype.beforeUpdate,
			afterUpdate: prototype.afterUpdate,
			beforeDestroy: prototype.beforeDestroy,
			afterDestroy: prototype.afterDestroy
		};

		instance.beforeValidate(function () {
			test.ok(true);
			instance.afterValidate(function () {
				test.ok(true);
				instance.beforeCreate(function () {
					test.ok(true);
					instance.afterCreate(instance, function (err, instance) {
						test.ok(true);
						instance.beforeUpdate(function () {
							test.ok(true);
							instance.afterUpdate(instance, function (err, instance) {
								test.ok(true);
								instance.beforeDestroy(function () {
									test.ok(true);
									instance.afterDestroy(instance, function () {
										test.ok(true);
									});
								});
							});
						});
					});
				});
			});
		});

		test.done();
	},
	validate: function (test) {
		test.expect(2);

		var instance = {
			constructor: {
				schema: {}
			},
			validate: prototype.validate
		};

		instance.constructor.schema.validate = function (attrs, cb) {
			cb(null);
		};

		sinon.spy(instance.constructor.schema, 'validate');

		instance.validate(function (err) {
			test.ifError(err);
			test.equal(instance.constructor.schema.validate.callCount, 1);
			test.done();
		});
	},
	noValidate: function (test) {
		test.expect(1);

		var instance = {
			validate: prototype.validate
		};

		instance.validate(function (err) {
			test.deepEqual(err, null);
			test.done();
		});
	},
	validateWithError: function (test) {
		test.expect(4);

		var instance = {
			constructor: {
				schema: {}
			},
			validate: prototype.validate
		};

		instance.constructor.schema.validate = function (attrs, cb) {
			cb({ error: 'test' });
		};

		sinon.spy(instance.constructor.schema, 'validate');

		instance.validate(function (err) {
			test.equal(err.type, 'ValidationError');
			test.equal(err.message, 'undefined#validate(cb): Validation failed!');
			test.deepEqual(err.errors, { error: 'test' });
			test.equal(instance.constructor.schema.validate.callCount, 1);
			test.done();
		});
	}
};