Testea comunicaciones de RestManager (cc916c10) · Commits · REDMIC Project / Client / Web

public/javascript/redmic/modules/store/RestManager.js

+14 −20

Original line number	Diff line number	Diff line
		@@ -46,8 +46,7 @@ define([
		},

		// TODO esto quizá no debería ir aquí, sino en el comunicador de errores
		defaultErrorDescription: 'Error',
		defaultErrorCode: '0'
		defaultErrorDescription: 'Error'
		};

		lang.mixin(this, this.config, args);
		@@ -259,7 +258,6 @@ define([
		var response = this._parseResponse(res);

		this._emitResponse({
		target: target,
		req: req,
		res: response,
		evtName: 'SAVE'
		@@ -370,42 +368,38 @@ define([
		});
		},

		// TODO revisar los emit!!!!!!!!!!!
		_emitResponse: function(params) {

		var target = params.target,
		req = params.req,
		var req = params.req,
		res = params.res,
		evtName = params.evtName;

		var response = lang.mixin({
		var response = {
		target: req.target,
		requesterId: req.requesterId
		}, res);
		requesterId: req.requesterId,
		req: req,
		res: res
		};

		this._emitLoaded(req);

		this._emitEvt(evtName, response);
		},

		_emitError: function(res) {
		_emitError: function(response) {

		var response = res.response,
		data = errObj.data,
		status = errObj.status;
		var status = response.status,
		error = response.error,
		description = error ? error : this.defaultErrorDescription;

		// TODO creo que estos valores por defecto deberían ponerse donde se escuchan, no aquí
		if (!response.code) {
		response.code = this.defaultErrorCode;
		}
		if (!response.description) {
		response.description = this.defaultErrorDescription/* + ' ' + (response.code \|\| '')*/;
		if (status) {
		description += ' - ' + status;
		}

		this._emitEvt('COMMUNICATION', {
		type: 'alert',
		level: 'error',
		description: response ? response.description : this.defaultErrorDescription
		description: description
		});
		}
		});

public/javascript/redmic/modules/store/RestManagerImpl.js

+39 −41

Original line number	Diff line number	Diff line
		@@ -192,47 +192,6 @@ define([
		return query;
		},

		// TODO REVISAR LOS PARSEEEEEEEEEEEEEEEEEEEEEEEEE!!!

		_parseResponse: function(res) {

		// TODO usar res.data directamente cuando no se envuelva la respuesta con body
		var data = res.data;
		if (data && data.body) {
		data = data.body;
		}

		return {
		status: res.status,
		data: data,
		text: res.text,
		url: res.url,
		getHeader: res.getHeader,
		options: res.options
		};
		},

		_parseError: function(res) {

		var response = res.response;

		// TODO usar response.data directamente cuando no se envuelva la respuesta con error
		var data = response.data;
		if (data && data.error) {
		data = data.error;
		}

		return {
		status: response.status,
		data: data,
		text: response.text,
		url: response.url,
		getHeader: response.getHeader,
		options: response.options,
		error: res.message
		};
		},

		_saveRequest: function(target, req) {

		var url = this._getSaveRequestTarget(target, req),
		@@ -313,6 +272,45 @@ define([
		timeout: this.timeout,
		handleAs: this.handleAs
		}, options);
		},

		_parseResponse: function(res) {

		// TODO usar res.data directamente cuando no se envuelva la respuesta con body
		var data = res.data;
		if (data && data.body) {
		data = data.body;
		}

		return {
		status: res.status,
		data: data,
		text: res.text,
		url: res.url,
		getHeader: res.getHeader,
		options: res.options
		};
		},

		_parseError: function(res) {

		var response = res.response;

		// TODO usar response.data directamente cuando no se envuelva la respuesta con error
		var data = response.data;
		if (data && data.error) {
		data = data.error;
		}

		return {
		status: response.status,
		data: data,
		text: response.text,
		url: response.url,
		getHeader: response.getHeader,
		options: response.options,
		error: res.message
		};
		}
		});
		});

tests/unit/redmic/modules/store/testRestManager.js

+429 −58

Original line number	Diff line number	Diff line
		define([
		"dojo/_base/declare"
		, "dojo/_base/lang"
		, "dojo/Deferred"
		, "redmic/base/Mediator"
		, "redmic/modules/store/RestManagerImpl"
		'dojo/_base/declare'
		, 'dojo/_base/lang'
		, 'dojo/Deferred'
		, 'redmic/base/Mediator'
		, 'redmic/modules/store/RestManagerImpl'

		], function(
		declare
		@@ -13,21 +13,23 @@ define([
		, RestManagerImpl
		) {

		var timeout, restManager, target, idExample, originalOpenMethod;
		var timeout, restManager, target, exampleId, originalOpenMethod, communicationChannel, exampleAction;

		var registerSuite = intern.getInterface('object').registerSuite,
		assert = intern.getPlugin('chai').assert;

		registerSuite("RestManager tests", {
		registerSuite('RestManager tests', {

		before: function() {

		timeout = 1000000;
		target = "http://localhost";
		idExample = 1;
		timeout = 100;
		target = 'http://localhost';
		exampleId = 1;
		communicationChannel = 'app:communicationCenter:communication';
		exampleAction = '_search';

		restManager = new RestManagerImpl({
		parentChannel: "app"
		parentChannel: 'app'
		});

		var envDfd = new Deferred();
		@@ -44,7 +46,7 @@ define([

		after: function() {

		Mediator.publish(restManager.getChannel("DISCONNECT"));
		Mediator.publish(restManager.getChannel('DISCONNECT'));
		},

		tests: {
		@@ -54,83 +56,452 @@ define([

		window.XMLHttpRequest.prototype.open = dfd.callback(function(method, url) {

		var expectedUrl = target + '/' + idExample;
		assert.strictEqual(url, expectedUrl, "La URL de petición no es la esperada");
		var expectedUrl = target + '/' + exampleId;
		assert.strictEqual(url, expectedUrl, 'La URL de petición no es la esperada');
		});

		Mediator.publish(restManager.getChannel("GET"), {
		Mediator.publish(restManager.getChannel('GET'), {
		target: target,
		id: idExample
		id: exampleId
		});
		},

		Should_PublishItemAvailable_When_ReceiveGetResponse: function() {
		Should_PublishItemAvailable_When_ReceiveGetSuccessResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + idExample,
		getReq = {},
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		status: 200,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('ITEM_AVAILABLE'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.deepEqual(res, args.getRes, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleGetSuccess(getReq, getRes);
		},

		Should_PublishItemAvailable_When_ReceiveGetErrorResponse: function() {

		var dfd = this.async(timeout),
		getReq = {},
		getRes = {
		response: {
		data: {}
		}
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		},
		args = {
		getTarget: getTarget,
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel("ITEM_AVAILABLE"), dfd.callback((function(args, res) {
		Mediator.once(restManager.getChannel('ITEM_AVAILABLE'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(res.target, args.getTarget, "La URL de respuesta no es la esperada");
		assert.strictEqual(res.req, args.getReq, "El objeto de petición no es el esperado");
		assert.strictEqual(res.res, args.getRes, "El objeto de respuesta no es el esperado");
		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.strictEqual(res.error, args.getRes.message, 'El mensaje de error no es el esperado');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.nestedInclude(res, args.getRes.response, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleGetSuccess(getTarget, getReq, getRes);
		restManager._handleGetError(getReq, getRes);
		},

		/*"Subscribe request data with query empty and pagination ": function() {
		var dfd = this.async(timeout);
		Mediator.once(restManager.getChannel("REQUEST"), dfd.callback(function(request) {
		assert.deepEqual(request.query, {}, "No se recibió la query enviada.");
		assert.deepEqual(request.target, "https://redmic.local/test/contacts/",
		"No se recibió el target enviado.");
		}));
		Mediator.publish(restManager.getChannel("REQUEST"), {query: {}, options: {},
		target: "https://redmic.local/test/contacts/"});
		Should_PublishErrorCommunication_When_ReceiveGetErrorResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		};

		Mediator.once(communicationChannel, dfd.callback((function(getRes, communication) {

		var description = communication.description;

		assert.include(description, getRes.response.status, 'El mensaje no contiene el código de error');
		assert.include(description, getRes.message, 'El mensaje no contiene el texto de error original');
		}).bind(null, getRes)));

		restManager._handleGetError(getReq, getRes);
		},

		Should_CreateExternalRequest_When_ReceiveRequestRequest: function() {

		"Publish available data with pagination 2 items": function() {
		var dfd = this.async(timeout);
		Mediator.once(restManager.getChannel("AVAILABLE"), dfd.callback(function(response) {
		assert.equal(response.body.data[0].id, 1, "El primer item debe tener id 1.");
		assert.equal(response.body.data[1].id, 2, "El segundo item debe tener id 2.");
		assert.equal(response.body.data.length, 2, "No se recibieron los datos esperados.");
		}));
		Mediator.publish(restManager.getChannel("REQUEST"), {query: {}, options: {start:1, count:2},
		target: "https://redmic.local/test/contacts/"});

		window.XMLHttpRequest.prototype.open = dfd.callback(function(method, url) {

		var expectedUrl = target + '/' + exampleAction;
		assert.strictEqual(url, expectedUrl, 'La URL de petición no es la esperada');
		});

		Mediator.publish(restManager.getChannel('REQUEST'), {
		target: target,
		action: exampleAction
		});
		},

		"Request data with error by global error channel (Timeout - wrong target)": function() {
		Should_PublishAvailable_When_ReceiveRequestSuccessResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleAction,
		getReq = {
		target: getTarget
		},
		getRes = {
		status: 200,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('AVAILABLE'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.deepEqual(res, args.getRes, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleRequestSuccess(getReq, getRes);
		},

		Should_PublishAvailable_When_ReceiveRequestErrorResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleAction,
		getReq = {
		target: getTarget
		},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('AVAILABLE'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.strictEqual(res.error, args.getRes.message, 'El mensaje de error no es el esperado');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.nestedInclude(res, args.getRes.response, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleRequestError(getReq, getRes);
		},

		Should_PublishErrorCommunication_When_ReceiveRequestErrorResponse: function() {

		var dfd = this.async(timeout),
		getReq = {},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		};

		Mediator.once(communicationChannel, dfd.callback((function(getRes, communication) {

		var description = communication.description;

		assert.include(description, getRes.response.status, 'El mensaje no contiene el código de error');
		assert.include(description, getRes.message, 'El mensaje no contiene el texto de error original');
		}).bind(null, getRes)));

		restManager._handleRequestError(getReq, getRes);
		},

		Should_CreateExternalRequest_When_ReceiveSaveRequest: function() {

		var dfd = this.async(timeout);
		Mediator.once(restManager.errorChannel, dfd.callback(function(item) {
		assert.isNotNull(item.error, "No se emitió el error correctamente");
		}));
		Mediator.publish(restManager.getChannel("REQUEST"), {query: {}, options: {},
		target: "https://redmic.local/test/contact/"});

		window.XMLHttpRequest.prototype.open = dfd.callback(function(method, url) {

		var expectedUrl = target + '/' + exampleId;
		assert.strictEqual(url, expectedUrl, 'La URL de petición no es la esperada');
		});

		Mediator.publish(restManager.getChannel('SAVE'), {
		target: target,
		id: exampleId,
		data: {}
		});
		},

		"Request data with error by local error channel (Timeout - wrong target)": function() {
		Should_PublishSaved_When_ReceiveSaveSuccessResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		status: 200,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('SAVED'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.deepEqual(res, args.getRes, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleSaveSuccess(getReq, getRes);
		},

		Should_PublishSaved_When_ReceiveSaveErrorResponse: function() {

		var dfd = this.async(timeout),
		getReq = {},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('SAVED'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.strictEqual(res.error, args.getRes.message, 'El mensaje de error no es el esperado');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.nestedInclude(res, args.getRes.response, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleSaveError(getReq, getRes);
		},

		Should_PublishErrorCommunication_When_ReceiveSaveErrorResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		};

		Mediator.once(communicationChannel, dfd.callback((function(getRes, communication) {

		var description = communication.description;

		assert.include(description, getRes.response.status, 'El mensaje no contiene el código de error');
		assert.include(description, getRes.message, 'El mensaje no contiene el texto de error original');
		}).bind(null, getRes)));

		restManager._handleSaveError(getReq, getRes);
		},

		Should_CreateExternalRequest_When_ReceiveRemoveRequest: function() {

		var dfd = this.async(timeout);
		Mediator.once(restManager.errorChannel, dfd.callback(function(item) {
		assert.isNotNull(item.error, "No se emitió el error correctamente");
		}));
		Mediator.publish(restManager.getChannel("REQUEST"), {query: {}, options: {},
		target: "https://redmic.local/test/contact/"});
		}*/
		}

		window.XMLHttpRequest.prototype.open = dfd.callback(function(method, url) {

		var expectedUrl = target + '/' + exampleId;
		assert.strictEqual(url, expectedUrl, 'La URL de petición no es la esperada');
		});

		Mediator.publish(restManager.getChannel('REMOVE'), {
		target: target,
		id: exampleId
		});
		},

		Should_PublishRemoved_When_ReceiveRemoveSuccessResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		status: 200,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('REMOVED'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.deepEqual(res, args.getRes, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleRemoveSuccess(getReq, getRes);
		},

		Should_PublishRemoved_When_ReceiveRemoveErrorResponse: function() {

		var dfd = this.async(timeout),
		getReq = {},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		},
		args = {
		getReq: getReq,
		getRes: getRes
		};

		Mediator.once(restManager.getChannel('REMOVED'), dfd.callback((function(args, response) {

		var req = response.req,
		res = response.res;

		assert.strictEqual(response.target, req.target, 'La URL de respuesta no es la esperada');
		assert.strictEqual(res.error, args.getRes.message, 'El mensaje de error no es el esperado');
		assert.deepEqual(req, args.getReq, 'El objeto de petición no es el esperado');
		assert.nestedInclude(res, args.getRes.response, 'El objeto de respuesta no es el esperado');
		}).bind(null, args)));

		restManager._handleRemoveError(getReq, getRes);
		},

		Should_PublishErrorCommunication_When_ReceiveRemoveErrorResponse: function() {

		var dfd = this.async(timeout),
		getTarget = target + '/' + exampleId,
		getReq = {
		target: getTarget
		},
		getRes = {
		response: {
		status: 500,
		data: {},
		text: undefined,
		getHeader: undefined,
		options: undefined,
		url: undefined
		},
		message: 'Error message'
		};

		Mediator.once(communicationChannel, dfd.callback((function(getRes, communication) {

		var description = communication.description;

		assert.include(description, getRes.response.status, 'El mensaje no contiene el código de error');
		assert.include(description, getRes.message, 'El mensaje no contiene el texto de error original');
		}).bind(null, getRes)));

		restManager._handleRemoveError(getReq, getRes);
		}
		}
		});
		});