400510405. Comprobación de unidades en la IU

Con el patrón Model-View-Presenter, Windows Forms 2.0 y la vinculación automática de datos podemos compilar una plataforma para la comprobación de unidades en la interfaz de usuario. El patrón aplica una separación de elementos que mantiene fina la IU, concentrándose sólo en la visualización de datos y vinculándose a un modelo de presentación.

En el presente artículo, voy a presentar una aplicación básica de calculadora que potencia esta arquitectura y que demuestra lo fácil que es la comprobación de unidades con esta plataforma. (El código fuente completo para la calculadora está disponible online; véase www.ddj.com/code ).

((El patrón aplica una separación de elementos que mantiene fina la IU, concentrándose sólo en la visualización de datos y vinculándose a un modelo de presentación))

Para los fines que persigue este artículo, podemos considerar el patrón Model-View-Presenter (MVP) como un medio de desemparejar la lógica de la presentación de la visualización misma. El objetivo debería ser un simple mapeado 1-1 entre propiedades en una clase de presentador y propiedades en una clase de visualización.

Por ejemplo, para cada presentación visual de un cuadro de texto, debería haber una propiedad correspondiente en la clase del presentador. Si el output necesita un cálculo avanzado o un formateado para que ocurra antes de que se visualice, las clases modelo y presentador deberían encargarse de los datos antes de actualizar la visualización.

((Las ediciones simples deberían notificar inmediatamente al modelo y al presentador de cualquier actualización para así producir una nueva presentación visual))

De igual forma, las ediciones simples deberían notificar inmediatamente al modelo y al presentador de cualquier actualización para así producir una nueva presentación visual. En muchos casos, además de nuestro sencillo ejemplo, las clases modelo y presentador pueden fusionarse en una clase modelo pesada.

Como se requiere poco código para convertir el modelo en datos presentables, el modelo puede gestionar la doble responsabilidad de almacenamiento de datos y la lógica de la presentación.

La aplicación de la calculadora

La Figura 1 ilustra una forma de calculadora básica ligada a un modelo de presentación de calculadora.

Cada elemento de datos a mostrar y editar en la visualización viene descrito por una propiedad, y cada acción de pinchado de un botón se representa con un método sin parámetro en el modelo de calculadora. Al seguir el patrón MVP garantizamos que la visualización se concentra en la visualización de datos además de enviar y recibir actualizaciones desde y hacia el modelo.

((

Listado 1

public class Calculator : INotifyPropertyChanged

public decimal Operand2

get return _operand2;

set

if (value == _operand2)

return;

_operand2 = value;

OnPropertyChanged(«Operand2»);

OnPropertyChanged(«CanDivide»);

public bool CanDivide

get return (this.Operand2 != 0);

…

))

El Listado número 1 incluye el código para dos de las propiedades del modelo de calculadora. En el listado, el fijador de una propiedad notifica a los consumidores una vez que se ha cometido un cambio. La clase Calculator implementa la interfaz INotifyPropertyChanged de .NET 2.0 para así dar soporte a eventos de disparo para los cambios de propiedades.

En el caso de Operand2, se actualiza CanDivide una vez que se ha actualizado Operand2, de manera que se disparan dos eventos.

((

listado 2

public partial class CalculatorForm : Form

public decimal Operand2

get return Convert.ToDecimal(_operand2TextBox.Text);

set _operand2TextBox.Text = value.ToString();

public bool CanDivide

get return _divideButton.Enabled;

set _divideButton.Enabled = value;

…

))

Para estas dos propiedades de modelos, hay propiedades análogas en la forma de calculadora; véase el Listado número 2. Estas propiedades en la visualización demuestran la preocupación de visualizar este estado del modelo.

Vinculación automática de datos

Una vez hemos creado un conjunto completo de propiedades en el modelo y en la visualización, podemos aplicar la vinculación de datos en CalculatorForm. En el Listado número 3 podemos vincular la propiedad Text del cuadro de texto a la propiedad Operand2 del modelo, y la propiedad Enabled del botón a la propiedad CanDivide del modelo.

Estos vínculos hacen que se actualice el modelo al producirse un cambio en la vista de Text Cuando cambia la propiedad CanDivide, se habilita/deshabilita el botón Divide.

((Al incentivar MVP y la vinculación automática de datos, podemos crear pruebas sencillas de unidades que cubren la mayor parte de las responsabilidades de la visualización. Si bien es cierto que algunas operaciones de visualización, como arrastrar y soltar, son difíciles de comprobar, la vinculación y la visualización son parte esencial de lo que ocurre en una vista))

Comprobación de unidades en la IU

Al usar MVP y la vinculación automática de datos, las pruebas de unidades para la visualización resultan sencillas Como la visualización es responsable ahora sólo de la visualización de valores y de responder a eventos vinculantes, podemos cubrir la mayor parte de la visualización con dos pruebas de unidades para cada propiedad de presentación visual.

((

Listado 3

public partial class CalculatorForm : Form

public CalculatorForm()

InitializeComponent();

InitializeBindings();

this.Calculator = new Calculator();

private void InitializeBindings()

_divideButton.DataBindings.Add(

«Enabled», _calculatorBindingSource,

«CanDivide», false,

DataSourceUpdateMode.OnPropertyChanged);

_operand2TextBox.DataBindings.Add(

«Text», _calculatorBindingSource,

«Operand2», false, DataSourceUpdateMode.OnPropertyChanged);

…

))

– TestVisualizingPropertyX
– TestBindingPropertyX
Con el fin de realizar una prueba de unidades para la visualización, es necesario lanzar Form o Control, e inspeccionar su estado inspeccionando los controles hijos en Form o Control. Puesto que los controles hijo dentro de un padre se representan de forma característica mediante variables privadas de miembros, podemos incentivar una clase Tester que extraiga los controles del padre.

En el Listado número 4, la clase GUITester utiliza la reflexión para atravesar la jerarquía del padre y extraer el control especificado mediante la propiedad Name del control.

[(

Listado 4

public static class GUITester

public static T FindControl(Control container, string name)

where T : Control

if (container is T && container.Name == name)

return container as T;

if (container.Controls.Count == 0)

return null;

foreach (Control child in container.Controls)

Control control = FindControl(child, name);

if (control != null)

return control as T;

return null;

#endregion

)]

Una vez que hemos extraído los controles hijo, es sencillo crear una prueba de unidades para validar esta visualización de una propiedad. Todo lo que necesitamos es lanzar la forma, actualizar la propiedad, y validar el estado del control; véase el Listado número 5.

((

Listado 5

[TestFixture)

public class CalculatorFormTest

(Test)

public void TestVisualizingOperand2()

CalculatorForm target = new CalculatorForm();

target.Show();

TextBox operand2TextBox =

GUITester.FindControl(target, «_operand2TextBox»);

_target.Operand2 = 100;

Assert.AreEqual(target.Operand2.ToString(),

_operand2TextBox.Text);

target.Close();

)]

Ahora que ya tenemos cobertura de pruebas para la visualización, tenemos que asegurarnos de que la vinculación funciona correctamente. Esto puede lograrse con una simple prueba de unidades que valide que el modelo y la visualización se mantienen sincronizados, como en el Listado número 6.

((

Listado 6

[TestFixture)

public class CalculatorFormTest

(Test)

public void TestBindingOperand2()

CalculatorForm target = new CalculatorForm();

Calculator model = target.Calculator();

target.Show();

// Update the UI and validate the model

target.Operand2 = 7;

Assert.AreEqual(target.Operand2, model.Operand2);

// Update the model and validate the UI

model.Operand2 = 9;

Assert.AreEqual(model.Operand2, target.Operand2);

target.Close();

)]

En tanto en cuanto creamos pruebas de unidades de este tipo para cada propiedad de presentación visual, podemos añadir una importante cantidad de cobertura con muy poco código para pruebas de unidades.

Conclusión

Al incentivar MVP y la vinculación automática de datos, podemos crear pruebas sencillas de unidades que cubren la mayor parte de las responsabilidades de la visualización. Si bien es cierto que algunas operaciones de visualización, como arrastrar y soltar, son difíciles de comprobar, la vinculación y la visualización son parte esencial de lo que ocurre en una vista.

((Además, podemos considerar superfluas las propiedades de envoltorio utilizadas en el ejemplo. Aunque no es necesario envolver cada cuadro de texto con su propia propiedad de presentación visual, el ejemplo sirve para demostrar lo sencillo que es crear el mapeado de uno a uno entre la propiedad de la presentación y la propiedad de la visualización))

Además, podemos considerar superfluas las propiedades de envoltorio utilizadas en el ejemplo. Aunque no es necesario envolver cada cuadro de texto con su propia propiedad de presentación visual, el ejemplo sirve para demostrar lo sencillo que es crear el mapeado de uno a uno entre la propiedad de la presentación y la propiedad de la visualización.

Como aplicar la norma a cada nueva aplicación dependerá de nosotros.

Siempre y cuando nos atengamos al espíritu de MVP, encontraremos un método sencillo para comprobar unidades en la visualización. DDJ