node-mocker-server/lib/ValidatorResponse.js

File based Node REST API mock server

'use strict';

var extend = require('util')._extend;
var GetResponse = require('./GetResponse');
var validatorLog = require('./ValidatorLog');
var ValidatorDataSchema = require('./ValidatorDataSchema');
var Utils = require('./Utils');

/**
 *
 * @class ValidatorResponse
 * @namespace ValidatorResponse
 * @param {object} options
 * @param {object} serverOptions
 * @constructor
 *
 * Swagger importer
 */
function ValidatorResponse(options, serverOptions) {
	this.init(options, serverOptions);
}

ValidatorResponse.prototype = extend(ValidatorResponse.prototype, Utils.prototype);
ValidatorResponse.prototype = extend(ValidatorResponse.prototype, {

	constructor: ValidatorResponse,

	_defaults: {
		path: undefined,
		method: undefined,
		expected: undefined,
	},

	/**
	 *
	 * @method init
	 * called by constructor
	 * @param {object} options
	 * @param {object} serverOptions
	 * @public
	 */
	init: function (options, serverOptions) {

		options = extend(this._defaults, options || {});

		this._options = options;
		this._serverOptions = serverOptions;
		this._isValid = true;
		this._path = this._options.path;
		this._method = this._options.method.toUpperCase();
		this._expected = this._options.expected;

		if (!this.isFilledString(this._path)) {
			this._isValid = false;
			validatorLog.error('<code>options.path</code> can\'t be empty!');
		}

		if (!this.isFilledString(this._method)) {
			this._isValid = false;
			validatorLog.error('<code>options.method</code> can\'t be empty!');
		}

		if (!this.isFilledString(this._expected)) {
			this._isValid = false;
			validatorLog.error('<code>options.expected</code> can\'t be empty!');
		}

		if (this._isValid) {
			this._pathMethod = this._path + '/' + this._method;
			this._pathSchema = this._pathMethod + '/response_schema.json';
			this._pathMockData = this._pathMethod + '/mock/' + this._expected;
			this._dataSchema = {};
			this._dataExpected = {};
			this._readFiles();
		}

		if (this._isValid) {
			return new ValidatorDataSchema({
				schema: this._dataSchema,
				data: this._dataExpected,
				path: this._pathMethod,
				expected: this._expected,
				restPath: this._serverOptions.restPath,
				filePathData: this._pathMockData,
			});
		}

	},

	/**
	 * @method _readFiles
	 * @returns {void}
	 * @private
	 */
	_readFiles: function () {

		var response;
		var cleanedPath = this._cleanPath(this._serverOptions, this._pathMockData);

		if (this._isValid) {
			try {
				this._dataSchema = JSON.parse(this.readFile(this._pathSchema));
			} catch (err) {
				validatorLog.success('Mock data in file <code>' + cleanedPath + '</code> are valid!');
				this._isValid = false;
			}

			response = new GetResponse({
				path: this._path,
				method: this._method,
				expected: this._expected,
			}, this._serverOptions);

			this._dataExpected = response.get();
		}
	},

	/**
	 *
	 * @method cleanPath
	 * @param {Object} options
	 * @param {String} path
	 * @returns {String}
	 * @private
	 */
	_cleanPath: function (options, path) {

		if (typeof path !== 'string') {
			return '';
		}

		if (typeof options !== 'object' || !options.restPath) {
			return path;
		}

		return path.replace(options.restPath, '');
	},

});

module.exports = ValidatorResponse;