martes, octubre 27, 2009

Munq - Inversión de Control para ASP.NET MVC

Buscando un contenedor de inversión de control (IoC Container en ingles) ligero para utilizar en una aplicación ASP.NET MVC me encontré con Munq el cual esta escrito a partir del código de Funq. Me pareció muy fácil de configurar así que grabe un pequeño screencast (4 min), usando jing, en el cual muestro como configurarlo para usarlo con la aplicación que crea la platilla de nuevo proyecto ASP.NET MVC 1 en Visual Studio.

Para ver directamente desde el sitio de jing haz clic aquí.

miércoles, octubre 21, 2009

TDD ¿Por qué escribir primero las pruebas?

Hace poco leí el blog post de Eber Irigoyen donde escribe sobre duct tape programming. Lo que me llamo la atención en ese post es que Eber mencionó que al escribir pruebas, estas no las hace antes de escribir el código necesario para que las pruebas pasen e incluso menciona que la idea de escribir la prueba primero la considera algo tonta (no son sus palabras exactas pero es la idea). En lo personal la idea de escribir la prueba antes del código lo considero como una buena practica y no pensaría que es algo tonto.

Muchas de las veces cuando se me solicita realizar un nuevo programa o agregar funcionalidad a uno ya existente primero se realiza una entrevista con el usuario final, analista de negocio o cliente (de ahora en adelante lo llamaré cliente) que solicita la funcionalidad. Para que ahí explique a detalle que es lo que necesita. En ocasiones al cliente se le dificulta expresar que es lo que realmente necesita y eso se debe en gran parte porque el tampoco esta seguro que es lo que realmente necesita.

He notado que esto sucede principalmente cuando el cliente, al empezar a explicar el problema y lo que desea lograr con la nueva funcionalidad, esta pensando en la solución que le ayudará a resolver su problema. Inicia explicando como es que ve su solución en lugar de explicar el problema o lo que quiere lograr con ello. En ocasiones se empieza a discutir la implementación de esa solución y que problemas pudiéramos encontrar, después se discute como es que se podría ayudar a resolver esos problemas. Así la discusión puede continuar centrándose en como resolver los problemas de una posible solución que pudiera o no ser la ideal.

Si el desarrollo se centra en hacer que la posible solución funcione, se corre el riesgo que al terminar el desarrollo, esta no cumpla con las expectativas del cliente, ya que lo que se tomo en cuenta para desarrollarla fue la posible solución en lugar de lograr que el problema inicial del cliente se resolviera. Esto hace que el cliente se de cuenta que la solución no le sirve del todo pero el desarrollador siente que cumplió porque hizo que funcionara lo que le pidieron.

Cuando el cliente se centra primero en explicar el problema y en especificar lo que espera lograr, en lugar de pensar en la posible solución. Es entonces cuando yo como profesional puedo trabajar en un programa que resuelva su problema y logre lo que él espera.

Del mismo modo cuando el desarrollador inicia escribiendo el código que resuelva un problema sin especificar antes que es lo que quiere lograr con ello. Es posible que termine escribiendo código que no va a necesitar. Esto es porque se centra en escribir una solución robusta en lugar de solo resolver el problema.

Por eso que pienso que el escribir lo que esperamos del código, como una prueba unitaria, antes de escribir la implementación nos da la ventaja de centrarnos en lo que realmente es importante: cumplir con al expectativa. Y no tanto en hacer que nuestra posible solución funcione. De igual forma ayuda a no escribir código que posiblemente no se necesite, ya que la prioridad es hacer que la prueba unitaria (especificación) pase.

Considero que es benéfico que al iniciar el desarrollo de nueva funcionalidad primero se especifiquen las expectativas que se tienen sobre ella y después se evalúe en base a esas especificaciones. Las expectativas se escriben usando pruebas unitarias y es por eso que me gusta que las pruebas se escriban primero.

El desarrollo guidado por pruebas o TDD (Test Driven Development) no solo se trata de las pruebas. TDD es una tarea de diseño.

viernes, octubre 09, 2009

VB XML Literals – Parte 3 LinqToXml

Siguiendo con la serie de post sobre VB XML Literals en esta ocasión en lugar de copiar y pegar el código utilicé Jing para grabar un screencast de 5 minutos donde explico como buscar dentro de un archivo xml usando LinqToXml en VB XML Literals

Ver screencast desde el sitio Jing

Post Relacionados
VB XML Literals Parte 2
VB XML Literals Parte 1

lunes, octubre 05, 2009

VB XML Literals - Parte 2

En la parte 1 de esta serie de posts sobre XML Literals expliqué en el ejemplo como cargar un objeto a partir de un archivo xml. Ahora veré el caso contrario: A partir de un objeto Order creare un archivo xml con la información de la orden. Este es el test con que comprobaré que mi método esta funcionando:

[TestMethod]
public void should_save_order_to_file()
{
var fileName = @"..\..\Order_Temp.xml";

if (File.Exists(fileName)) File.Delete(fileName);

var order = CreateSampleOrder();

var orderXmlTasks = new OrderXmlTasks();
orderXmlTasks.SaveToFile(fileName, order);

File.Exists(fileName).Should().Be.True();

var fileLines = File.ReadAllLines(fileName);
var expectedLines = CreateExpectedXml();
for (int i = 0; i < fileLines.Length; i++)
{
var line = fileLines[i].Trim();
line.Should().Be.EqualTo(expectedLines[i]);
}
}

public Order CreateSampleOrder()
{
return new Order
{
Id = 321,
Customer = "Peter Griffin",
Items = new List<OrderItem>
{
new OrderItem { ProductId = 3, Quantity = 1, Price = 2.05m, Description = "product x" },
new OrderItem { ProductId = 7, Quantity = 4, Price = 3.45m, Description = "product y" },
new OrderItem { ProductId = 8, Quantity = 9, Price = 5.50m, Description = "product z" },
}
};
}

public string[] CreateExpectedXml()
{
var xml = new List<string>();

xml.Add("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
xml.Add("<order id=\"321\" xmlns=\"urn:schemas-developeando-com:xmlLiterals\">");
xml.Add("<customer>Peter Griffin</customer>");
xml.Add("<items>");
xml.Add("<item productId=\"3\" quantity=\"1\" price=\"2.05\">product x</item>");
xml.Add("<item productId=\"7\" quantity=\"4\" price=\"3.45\">product y</item>");
xml.Add("<item productId=\"8\" quantity=\"9\" price=\"5.50\">product z</item>");
xml.Add("</items>");
xml.Add("</order>");

return xml.ToArray();
}

Lo que hace el test es crear una orden de ejemplo (CreateSampleOrder), escribir los datos de la orden en un archivo xml y después leo el archivo generado y lo comparo con el xml esperado (CreateExpectedXml)

Generar xml usando XML Literals es tan simple como solo escribir el XML y agregar expresiones donde queremos insertar código. Entonces el código para que la prueba pase queda así:

Public Sub SaveToFile(ByVal FileName As String, ByVal Order As Order)
Dim xml = <order id=<%= Order.Id %>>
<
customer><%= Order.Customer %></customer>
<
items>
<%= From item In Order.Items _
Select <item
productId=<%= item.ProductId %>
quantity=<%= item.Quantity %>
price=<%= item.Price %>>
<%= item.Description %>
</item> %>
</items>
</
order>
xml.Save(FileName)
End Sub

Como se puede apreciar solo declaro una variable y le asigno el xml, usando expresiones para indicar donde quiero escribir los valores de las propiedades del objeto Order. Para los items utilizo una expresión LINQ para indicar que por cada item agregue un elemento <item> y asigno el valor a los atributos y el valor de la descripción en el texto interno.