Commit 34c47198 authored by Pedro Eduardo Trujillo's avatar Pedro Eduardo Trujillo
Browse files

Revisa e incrementa tests de Selector, corrige bug 

Añade nuevos casos de prueba y corrige fallo detectado en el módulo
gracias a ellos: al limpiar una selección con target local, nunca se
respondía, porque se esperaba una respuesta que nunca llegaría.
parent 3c07cfd5

public/javascript/redmic/modules/selector/Selector.js

+40 −35
Original line number Diff line number Diff line 
define([

	"dojo/_base/declare"

	, "dojo/_base/lang"

	, "dojo/Deferred"

	, "dojo/promise/all"

	, "redmic/modules/base/_Module"

	, "redmic/modules/base/_SelectionBase"

	, "RWidgets/Utilities"

	, "./_SelectorItfc"

	, "./_SelectorPersistence"

	'dojo/_base/declare'

	, 'dojo/_base/lang'

	, 'dojo/Deferred'

	, 'dojo/promise/all'

	, 'redmic/modules/base/_Module'

	, 'redmic/modules/base/_SelectionBase'

	, 'RWidgets/Utilities'

	, './_SelectorItfc'

	, './_SelectorPersistence'

], function(

	declare

	, lang
@@ -29,7 +29,7 @@ define([ 
		constructor: function(args) {



			this.config = {

				ownChannel: "selection",

				ownChannel: 'selection',

				selections: {}

			};
@@ -39,20 +39,20 @@ define([ 
		_defineSubscriptions: function() {



			this.subscriptionsConfig.push({

				channel : this.getChannel("SELECT"),

				callback: "_subSelect"

				channel : this.getChannel('SELECT'),

				callback: '_subSelect'

			},{

				channel : this.getChannel("DESELECT"),

				callback: "_subDeselect"

				channel : this.getChannel('DESELECT'),

				callback: '_subDeselect'

			},{

				channel : this.getChannel("GROUP_SELECTED"),

				callback: "_subGroupSelected"

				channel : this.getChannel('GROUP_SELECTED'),

				callback: '_subGroupSelected'

			},{

				channel : this.getChannel("CLEAR_SELECTION"),

				callback: "_subClearSelection"

				channel : this.getChannel('CLEAR_SELECTION'),

				callback: '_subClearSelection'

			},{

				channel : this.getChannel("TOTAL"),

				callback: "_subTotal"

				channel : this.getChannel('TOTAL'),

				callback: '_subTotal'

			});

		},
@@ -60,25 +60,25 @@ define([ 


			this.publicationsConfig.push({

				event: 'SELECT',

				channel: this.getChannel("SELECTED")

				channel: this.getChannel('SELECTED')

			},{

				event: 'DESELECT',

				channel: this.getChannel("DESELECTED")

				channel: this.getChannel('DESELECTED')

			},{

				event: 'GROUP_SELECTED',

				channel: this.getChannel("SELECTED_GROUP")

				channel: this.getChannel('SELECTED_GROUP')

			},{

				event: 'CLEAR_SELECTION',

				channel: this.getChannel("SELECTION_CLEARED")

				channel: this.getChannel('SELECTION_CLEARED')

			},{

				event: 'TOTAL',

				channel: this.getChannel("TOTAL_AVAILABLE")

				channel: this.getChannel('TOTAL_AVAILABLE')

			},{

				event: 'SELECTION_TARGET_LOADING',

				channel: this.getChannel("SELECTION_TARGET_LOADING")

				channel: this.getChannel('SELECTION_TARGET_LOADING')

			},{

				event: 'SELECTION_TARGET_LOADED',

				channel: this.getChannel("SELECTION_TARGET_LOADED")

				channel: this.getChannel('SELECTION_TARGET_LOADED')

			});

		},
@@ -90,8 +90,9 @@ define([ 
			this._emitSelectionTargetLoading(target);

			this._initializeSelection(target);



			if (typeof items !== "object") {

			if (typeof items !== 'object') {

				items = [items];

				req.items = items;

			}



			if (target.indexOf('{apiUrl}') !== -1) {
@@ -171,8 +172,9 @@ define([ 
			this._emitSelectionTargetLoading(target);

			this._initializeSelection(target);



			if (typeof items !== "object") {

			if (typeof items !== 'object') {

				items = [items];

				req.items = items;

			}



			if (target.indexOf('{apiUrl}') !== -1) {
@@ -246,13 +248,14 @@ define([ 


		_subClearSelection: function(req) {



			this._clearSelectionSave(req);

		},



		_clearSelectionSave: function(req) {

			var target = req.target;



			this._emitSelectionTargetLoading(req.target);

			if (target.indexOf('{apiUrl}') !== -1) {

				this._emitSelectionTargetLoading(target);

				this._emitSave(this._getDataToSave('CLEAR_SELECTION', req));

			} else {

				this._clearSelection(target);

			}

		},



		_clearSelection: function(target) {
@@ -296,6 +299,8 @@ define([ 


		_selectById: function(itemPath, target) {



			this._initializeSelection(target);



			if (!this._getItems(target)[itemPath]) {

				this.selections[target].items[itemPath] = true;

				this.selections[target].total++;

public/javascript/redmic/modules/selector/_SelectorPersistence.js

+8 −8
Original line number Diff line number Diff line 
define([

	"dojo/_base/declare"

	, "dojo/_base/lang"

	, "redmic/modules/base/_Persistence"

	, "redmic/modules/base/_Store"

	, "redmic/base/Credentials"

	'dojo/_base/declare'

	, 'dojo/_base/lang'

	, 'redmic/modules/base/_Persistence'

	, 'redmic/modules/base/_Store'

	, 'redmic/base/Credentials'

], function(

	declare

	, lang
@@ -281,7 +281,7 @@ define([ 


		_getTargetWithoutSelectionSuffix: function(target) {



			return this._cleanTrailingSlash(target).replace(this.selectionTargetSuffix, "");

			return this._cleanTrailingSlash(target).replace(this.selectionTargetSuffix, '');

		},



		_errorAvailable: function(error, status, resWrapper) {
@@ -297,12 +297,12 @@ define([ 


		_getSelectionIds: function() {



			return Credentials.get("selectIds") || {};

			return Credentials.get('selectIds') || {};

		},



		_setSelectionIds: function(selectionIds) {



			Credentials.set("selectIds", selectionIds);

			Credentials.set('selectIds', selectionIds);

		}

	});

});

tests/unit/redmic/modules/selector/testSelector.js

+305 −26
Original line number Diff line number Diff line
@@ -3,15 +3,17 @@ define([ 
	, 'dojo/_base/lang'

	, 'redmic/base/Mediator'

	, 'redmic/modules/selector/Selector'



], function(

	declare

	, lang

	, Mediator

	, Selector

) {



	var timeout = 100,

		target = '{apiUrl}/data',

		settingsTarget = '{apiUrl}/{endpoint}/data',

		localTarget = 'local/data',

		selector;



	var registerSuite = intern.getInterface('object').registerSuite,
@@ -38,23 +40,52 @@ define([ 
		tests: {

			Should_HaveSelectionStructureAvailable_When_ModuleIsInitialized: function() {



				assert(selector.selections, 'La estructura de seleccionados no se ha creado correctamente');

				assert.ok(selector.selections, 'La estructura de seleccionados no se ha creado correctamente');

			},



			Should_EmitSaveForSelection_When_SelectItem: function() {



				var dfd = this.async(timeout);



				selector._onceEvt('SAVE', function(evt) {

				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.include(evt.data.ids, 1, 'El item seleccionado debe tener id 1');

					assert.strictEqual(evt.data.action, 'select', 'La acción para guardar debe ser la de seleccionar');

				}));



					dfd.resolve();

				Mediator.publish(selector.getChannel('SELECT'), {

					target: target,

					items: 1

				});

			},



			Should_EmitSaveForSettingsSelection_When_SelectItem: function() {



				var dfd = this.async(timeout);



				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.include(evt.data.selection, 1, 'El item seleccionado debe tener id 1');

				}));



				Mediator.publish(selector.getChannel('SELECT'), {

					target: target,

					target: settingsTarget,

					items: 1

				});

			},



			Should_HaveItemInSelection_When_PublishSelectedForLocalSelection: function() {



				var dfd = this.async(timeout);



				Mediator.once(selector.getChannel('SELECTED'), dfd.callback(function(res) {



					assert.include(res.ids, '1', 'El item seleccionado debe tener como id la cadena "1"');

					assert.ok(selector.selections[localTarget].items[1], 'El item con id 1 debe estar seleccionado');

				}));



				Mediator.publish(selector.getChannel('SELECT'), {

					target: localTarget,

					items: 1

				});

			},
@@ -79,20 +110,73 @@ define([ 
				selector._select([1], target);

			},



			Should_OmitSaveForSettingsSelectionEmission_When_SelectAlreadySelectedItem: function() {



				var dfd = this.async(timeout),

					callback = function(res) {



						dfd.reject(new Error('Se ha publicado "selected" para un elemento ya seleccionado'));

					};



				setTimeout(dfd.callback(function() {



					Mediator.remove(selector.getChannel('SELECTED'), callback);

				}), timeout - 1);



				selector._select([1], settingsTarget);



				Mediator.once(selector.getChannel('SELECTED'), callback);



				selector._select([1], settingsTarget);

			},



			Should_EmitSaveForSelection_When_SelectSeveralItems: function() {



				var dfd = this.async(timeout);



				selector._onceEvt('SAVE', function(evt) {

				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.lengthOf(evt.data.ids, 3, 'El array de items debe tener longitud 3');

					assert.strictEqual(evt.data.action, 'select', 'La acción para guardar debe ser la de seleccionar');

				}));



				Mediator.publish(selector.getChannel('SELECT'), {

					target: target,

					items: [1, 2, 3]

				});

			},



			Should_EmitSaveForSettingsSelection_When_SelectSeveralItems: function() {



				var dfd = this.async(timeout);



				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.lengthOf(evt.data.selection, 3, 'El array de items debe tener longitud 3');

				}));



					dfd.resolve();

				Mediator.publish(selector.getChannel('SELECT'), {

					target: settingsTarget,

					items: [1, 2, 3]

				});

			},



			Should_HaveItemsInSelection_When_PublishSelectedForMultipleLocalSelection: function() {



				var dfd = this.async(timeout);



				Mediator.once(selector.getChannel('SELECTED'), dfd.callback(function(res) {



					assert.includeMembers(res.ids, ['1', '2', '3'],

						'Los items seleccionados deben tener como ids las cadenas correspondientes a sus id');



					assert.ok(selector.selections[localTarget].items[1], 'El item con id 1 debe estar seleccionado');

					assert.ok(selector.selections[localTarget].items[2], 'El item con id 2 debe estar seleccionado');

					assert.ok(selector.selections[localTarget].items[3], 'El item con id 3 debe estar seleccionado');

				}));



				Mediator.publish(selector.getChannel('SELECT'), {

					target: target,

					target: localTarget,

					items: [1, 2, 3]

				});

			},
@@ -106,16 +190,59 @@ define([ 
					items: 1

				});



				selector._onceEvt('SAVE', function(evt) {

				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.include(evt.data.ids, 1, 'El item deseleccionado debe tener id 1');

					assert.strictEqual(evt.data.action, 'deselect', 'La acción para guardar debe ser la de deseleccionar');

					assert.strictEqual(evt.data.action, 'deselect',

						'La acción para guardar debe ser la de deseleccionar');

				}));



				Mediator.publish(selector.getChannel('DESELECT'), {

					target: target,

					items: 1

				});

			},



			Should_EmitSaveForSettingsDeselection_When_DeselectItem: function() {



				var dfd = this.async(timeout);



					dfd.resolve();

				Mediator.publish(selector.getChannel('SELECT'), {

					target: settingsTarget,

					items: 1

				});



				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.include(evt.data.selection, 1, 'El item deseleccionado debe tener id 1');

				}));



				Mediator.publish(selector.getChannel('DESELECT'), {

					target: target,

					target: settingsTarget,

					items: 1

				});

			},



			Should_NotHaveItemInSelection_When_PublishDeselectedForLocalSelection: function() {



				var dfd = this.async(timeout);



				Mediator.publish(selector.getChannel('SELECT'), {

					target: localTarget,

					items: 1

				});



				Mediator.once(selector.getChannel('DESELECTED'), dfd.callback(function(res) {



					assert.include(res.ids, '1', 'El item deseleccionado debe tener como id la cadena "1"');

					assert.notOk(selector.selections[localTarget].items[1], 'El item con id 1 debe estar seleccionado');

				}));



				assert.ok(selector.selections[localTarget].items[1],

					'El item con id 1 debe estar previamente seleccionado');



				Mediator.publish(selector.getChannel('DESELECT'), {

					target: localTarget,

					items: 1

				});

			},
@@ -138,6 +265,24 @@ define([ 
				selector._deselect([1], target);

			},



			Should_OmitSaveForSettingsDeselectionEmission_When_DeselectAlreadyDeselectedItem: function() {



				var dfd = this.async(timeout),

					callback = function(res) {



						dfd.reject(new Error('Se ha publicado "deselected" para un elemento ya deseleccionado'));

					};



				setTimeout(dfd.callback(function() {



					Mediator.remove(selector.getChannel('DESELECTED'), callback);

				}), timeout - 1);



				Mediator.once(selector.getChannel('DESELECTED'), callback);



				selector._deselect([1], settingsTarget);

			},



			Should_EmitSaveForDeselection_When_DeselectSeveralItems: function() {



				var dfd = this.async(timeout);
@@ -146,16 +291,74 @@ define([ 


				assert.strictEqual(selector._getTotal(target), 3, 'El total antes del deselect debe ser igual a 3');



				selector._onceEvt('SAVE', function(evt) {

				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.lengthOf(evt.data.ids, 3, 'El array de items debe tener longitud 3');

					assert.strictEqual(evt.data.action, 'deselect', 'La acción para guardar debe ser la de seleccionar');

					assert.strictEqual(evt.data.action, 'deselect',

						'La acción para guardar debe ser la de seleccionar');

				}));



					dfd.resolve();

				Mediator.publish(selector.getChannel('DESELECT'), {

					target: target,

					items: [1, 2, 3]

				});

			},



			Should_EmitSaveForSettingsDeselection_When_DeselectSeveralItems: function() {



				var dfd = this.async(timeout);



				selector._select([1, 2, 3], settingsTarget);



				assert.strictEqual(selector._getTotal(settingsTarget), 3,

					'El total antes del deselect debe ser igual a 3');



				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.lengthOf(evt.data.selection, 3, 'El array de items debe tener longitud 3');

				}));



				Mediator.publish(selector.getChannel('DESELECT'), {

					target: target,

					target: settingsTarget,

					items: [1, 2, 3]

				});

			},



			Should_NotHaveItemsInSelection_When_PublishDeselectedForMultipleLocalSelection: function() {



				var dfd = this.async(timeout);



				Mediator.publish(selector.getChannel('SELECT'), {

					target: localTarget,

					items: [1, 2, 3]

				});



				Mediator.once(selector.getChannel('DESELECTED'), dfd.callback(function(res) {



					assert.includeMembers(res.ids, ['1', '2', '3'],

						'Los items seleccionados deben tener como ids las cadenas correspondientes a sus id');



					assert.notOk(selector.selections[localTarget].items[1],

						'El item con id 1 debe estar seleccionado');



					assert.notOk(selector.selections[localTarget].items[2],

						'El item con id 2 debe estar deseleccionado');



					assert.notOk(selector.selections[localTarget].items[3],

						'El item con id 3 debe estar deseleccionado');

				}));



				assert.ok(selector.selections[localTarget].items[1],

					'El item con id 1 debe estar previamente seleccionado');



				assert.ok(selector.selections[localTarget].items[2],

					'El item con id 2 debe estar seleccionado');



				assert.ok(selector.selections[localTarget].items[3],

					'El item con id 3 debe estar seleccionado');



				Mediator.publish(selector.getChannel('DESELECT'), {

					target: localTarget,

					items: [1, 2, 3]

				});

			},
@@ -167,21 +370,67 @@ define([ 


				selector._select(selectionArray, target);



				Mediator.once(selector.getChannel('SELECTED_GROUP'), function(res) {

				Mediator.once(selector.getChannel('SELECTED_GROUP'), dfd.callback(function(res) {



					var selection = res.selection;



					assert.strictEqual(res.target, target, 'El target del servicio no corresponde con el enviado');



					assert.lengthOf(Object.keys(selection), 2, 'El total de seleccionados recibido no es el esperado');

					assert(selection[1], 'El item con id 1 no está seleccionado');

					assert(selection[2], 'El item con id 2 no está seleccionado');

					assert.ok(selection[1], 'El item con id 1 no está seleccionado');

					assert.ok(selection[2], 'El item con id 2 no está seleccionado');

				}));



					dfd.resolve();

				Mediator.publish(selector.getChannel('GROUP_SELECTED'), {

					target: target

				});

			},



			Should_PublishSelectedGroup_When_ReceiveSettingsGroupSelectedRequest: function() {



				var dfd = this.async(timeout),

					selectionArray = [1, 2];



				selector._select(selectionArray, settingsTarget);



				Mediator.once(selector.getChannel('SELECTED_GROUP'), dfd.callback(function(res) {



					var selection = res.selection;



					assert.strictEqual(res.target, settingsTarget,

						'El target del servicio no corresponde con el enviado');



					assert.lengthOf(Object.keys(selection), 2, 'El total de seleccionados recibido no es el esperado');

					assert.ok(selection[1], 'El item con id 1 no está seleccionado');

					assert.ok(selection[2], 'El item con id 2 no está seleccionado');

				}));



				Mediator.publish(selector.getChannel('GROUP_SELECTED'), {

					target: target

					target: settingsTarget

				});

			},



			Should_PublishSelectedGroup_When_ReceiveLocalGroupSelectedRequest: function() {



				var dfd = this.async(timeout),

					selectionArray = [1, 2];



				selector._select(selectionArray, localTarget);



				Mediator.once(selector.getChannel('SELECTED_GROUP'), dfd.callback(function(res) {



					var selection = res.selection;



					assert.strictEqual(res.target, localTarget,

						'El target del servicio no corresponde con el enviado');



					assert.lengthOf(Object.keys(selection), 2, 'El total de seleccionados recibido no es el esperado');

					assert.ok(selection[1], 'El item con id 1 no está seleccionado');

					assert.ok(selection[2], 'El item con id 2 no está seleccionado');

				}));



				Mediator.publish(selector.getChannel('GROUP_SELECTED'), {

					target: localTarget

				});

			},
@@ -192,16 +441,46 @@ define([ 


				selector._select(selectionArray, target);



				selector._onceEvt('SAVE', function(evt) {

				selector._onceEvt('SAVE', dfd.callback(function(evt) {



					assert.strictEqual(evt.data.action, 'clearSelection',

						'La acción para guardar debe ser la de limpiar selección');

				}));



					dfd.resolve();

				Mediator.publish(selector.getChannel('CLEAR_SELECTION'), {

					target: target

				});

			},



			Should_EmitSaveForClearSelection_When_ClearSelectionBySettingsTarget: function() {



				var dfd = this.async(timeout),

					selectionArray = [1, 2];



				selector._select(selectionArray, settingsTarget);



				selector._onceEvt('SAVE', dfd.callback(function(evt) {}));



				Mediator.publish(selector.getChannel('CLEAR_SELECTION'), {

					target: settingsTarget

				});

			},



			Should_PublishSelectionCleared_When_ClearSelectionByLocalTarget: function() {



				var dfd = this.async(timeout),

					selectionArray = [1, 2];



				selector._select(selectionArray, localTarget);



				Mediator.once(selector.getChannel('SELECTION_CLEARED'), dfd.callback(function(res) {



					assert.isEmpty(selector.selections[localTarget].items,

						'Los elementos seleccionados no se han limpiado correctamente');

				}));



				Mediator.publish(selector.getChannel('CLEAR_SELECTION'), {

					selectionTarget: target

					target: localTarget

				});

			}

		}