Pasando de Delphi 7 a RAD Studio 2007 (y 9)

Hoy vamos a terminar de ver las características más importantes que incorpora RAD Studio 2007.

Otra ventaja que incorporan las nuevas versiones de Delphi es la posibilidad es generar la documentación online de nuestro proyecto automáticamente utilizando la tecnología de Together.

También veremos el explorador de datos que incorpora que nos permite acceder a las tablas de las bases de datos sin tener que utilizar herramientas externas como IBConsole, IBExpert, etc.

GENERANDO DOCUMENTACIÓN AUTOMÁTICAMENTE

Para generar la documentación de la unidad UFacturacion que vimos en el artículo anterior debemos ir a la ventana del Model View pulsamos la unidad UFacturacion con el botón derecho del ratón y seleccionamos Generate Documentation:


Aparecerá una ventana donde podemos elegir la carpeta donde vamos a generar la documentación:


Si no modificamos nada en esta ventana lo que va a hacer es crear dentro de la carpeta de nuestro proyecto dos carpetas mas: out y dentro de esta doc donde finalmente irá la documentación.

Pulsamos el botón Ok y nos pedirá una última confirmación antes de proceder:


Cuando termine nos creará esta página web automáticamente:


En la parte superior de la página tenemos el diseño UML de nuestras clases. En la parte inferior izquierda está el índice de unidades disponibles y si pulsamos en una de ellas aparecerá a la derecha la documentación.

La documentación también puede generarse desde el menú superior seleccionando Tools -> Generate Documentation. Se puede generar documentación de sólo una unidad o bien de todo el proyecto.

De este modo, podemos distribuir nuestras librerías de código a otros programadores incorporando su documentación en línea siempre actualizada.

Aunque es una auténtica gozada poder generar la documentación de este modo se hecha mucho de menos poder manipular el formato de salida así como añadir comentarios opcionales y descripciones a la clase, los métodos y sus campos (variables).

ACCEDIENDO A LAS BASES DE DATOS CON DATA EXPLORER

Al igual que tenemos la pestaña Model View en la ventana del proyecto (Project Manager) también tenemos la última pestaña llamada Data Explorer. Esta pestaña nos permite acceder a las tablas de bases de datos como pueden ser Internase/Firebird, Oracle, MySQL, etc.


Vamos a ver un ejemplo de cómo conectar con una base de datos Firerid utilizando esta herramienta. Lo primero que tenemos que hacer el pulsar INTERBASE con el botón derecho del ratón y seleccionar Add New Connection:


Se abrirá una nueva ventana en la que tenemos que escribir el nombre que le vamos a dar a la conexión:


Pulsamos el botón Ok y veremos la conexión creada debajo de la rama INTERBASE:


Pulsamos esa conexión con el botón derecho de ratón y seleccionamos Modify Connection:


Se abrirá una ventana de configuración en la que debemos configura una conexión DBExpress para conectar con nuestra base de datos:


Una vez introducidos los parámetros de la conexión pulsamos el botón Test Connection para comprobar si todo ha ido bien. Nos tiene que mostrar este mensaje:


Después pulsamos Ok y si abrimos el apartado Tables del nuestra conexión deben verse todas las tablas de nuestra base de datos:


Al hacer doble clic sobre una tabla nos abrirá una nuestra pestaña en el editor de código con una rejilla preparada para modificar los campos de la tabla:


Si hacemos cualquier modificación sobre un registro podemos actualizarlo definitivamente enviando la transacción al servidor pulsando la tabla con el botón derecho del ratón y seleccionando Update:


Igualmente podemos deshacer los cambio pulsando sobre la opción Rollback.

Si abrimos una tabla no sólo podemos ver los nombres de los campos, sino que además se pueden ver sus índices:


Se pueden alterar los metadatos de una tabla seleccionándola con el botón derecho del ratón y eligiendo la opción Alter table:


Nos abrirá una nueva pestaña en medio del editor para modificar los campos creados:


De esta forma se pueden ampliar los campos String a más caracteres sin tener que realizar ninguna SQL. Cuando terminemos de realizar las modificaciones pulsamos la rejilla con el botón derecho del ratón y seleccionamos Save Changes:


Si antes de guardar los cambios seleccionamos la opción Show DLL nos mostrará la SQL que va a ejecutar para realizar las modificaciones:


No es que sea ninguna maravilla de editor de tablas como pueden ser IBConsole o IBExpert pero por lo menos nos permite ver los resultados de las operaciones de nuestro programa sin tener que salir del IDE.

Si nos interesa hacer alguna consulta avanzada entonces debemos seleccionar la conexión con el botón derecho del ratón y elegir SQL Window:


Esto abrirá una nueva pestaña en el centro de la ventana donde podemos escribir nuestras sentencias SQL:


En la parte inferior de este editor podemos escribir la consulta manualmente y luego pulsamos el botón Execute SQL:


Debajo de la sentencia SQL abrirá un apartado con el resultado de la operación:


Si no tenemos gana de escribir sentencias SQL se pueden realizar automáticamente haciendo doble clic sobre las tablas que hay a la derecha y pasarán al centro:


Además se creará abajo la sentencia SQL automáticamente. Incluso se pueden hacer asociaciones entre campos de varias tablas para hacer sentencias SQL más complejas:


Cuando terminemos de trabajar con la base de datos podemos cerrar la conexión pulsándola con el botón derecho del ratón y seleccionando Close connection:


Con esto doy finalizada esta serie de artículos relacionados sobre las diferencias principales entre Delphi 7 y RAD Studio 2007. Quizás en un futuro haga lo mismo entre Delphi 2007 y el recién nacido Delphi 2009 (Tiburón).

Pruebas realizadas con RAD Studio 2007.

Pasando de Delphi 7 a RAD Studio 2007 (8)

En este artículo vamos a ver como aprovechar las ventajas que incorpora RAD Studio 2007 para un analista/arquitecto de software.

EL DISEÑO DE MODELOS UML

Para cualquier tipo de proyecto tenemos en la ventana del proyecto la pestaña Model View que nos permite realizar modelos UML para crear nuestras clases. Cualquier cambio que se produzca en el diseño de una clase se reflejará inmediatamente en el código fuente.

Así mismo, si modificamos el código fuente de una clase se modificará su diseño UML de manera instantánea. Esto nos permite diseñar nuestros programas de una manera profesional sin tener que recurrir a herramientas externas.

COMO DISEÑAR UN MODELO

Supongamos que tenemos que diseñar e implementar un programa de facturación que va a tener unas cuantas clases relacionadas entre sí. En vez de picar código manualmente como hemos hecho hasta ahora lo vamos a diseñar todo utilizando modelos UML.

Lo primero que hay que hacer es crear una nueva unidad que va a contener nuestro código fuente. Seleccionamos en el menú superior File -> New -> Unit y guardamos la unidad con el nombre UFacturacion.pas.

Esto nos dejará una nueva unidad completamente limpia y lista para trabajar:


Ahora seleccionamos la pestaña Model View en la ventana del proyecto:


Al pulsar esta pestaña nos aparecerá este mensaje:


Nos dice que el proyecto actual no esta configurado para el modelado. Pulsamos el botón Sí y aparecerá el editor de modelos con la jerarquía de nuestro proyecto:


Abrimos la rama del proyecto, seleccionamos la unidad UFacturacion con el botón derecho del ratón y seleccionamos Open Diagram:


En la parte central del IDE aparecerá una nueva pestaña con el editor de modelos listo para comenzar a trabajar:


Si nos fijamos en la carpeta que contiene los archivos de nuestro proyecto aparecerá una nueva carpeta dentro llamada ModelSuport_NombreDelProyecto que contiene todos los archivos gráficos UML que vamos desarrollando:


Estos archivos se van actualizando en tiempo real respecto a nuestro código fuente y viceversa.

Vamos a crear nuestro primer modelo para la clase TArticulo. Pinchamos el fondo del editor de modelos con el botón derecho del ratón y seleccionamos Add -> Class:


Nos aparecerá el diseño de una nueva clase llamada Class1:


que vamos a renombrar por TArticulo:


Ahora vamos a añadir una variables a nuestra clase. Pinchamos la clase TArticulo con el botón derecho del ratón y seleccionamos Add -> Field lo que nos creará una nueva variable – campo (Field) con el nombre Field1:


Debemos escribir el nombre del campo, dos puntos y el tipo de variable, por ejemplo:

ID:Integer

Al pulsar Intro aparecerá el signo + a su izquierda:


Esto significa que hemos creado una variable pública. Si seleccionamos esta variable y nos fijamos en el inspector de objetos podemos modificar todas sus propiedades:


En el campo visibility podemos elegir el ámbito de la variable:


De este modo vamos añadiendo campos a nuestra clase hasta completar su diseño:


Si pulsamos la pestaña UFacturacion podemos ver como se refleja inmediatamente en el código fuente:


Todo esto lo hemos hecho sin teclear ni una línea de código. Lo más sorprendente es que si yo añado una variable a la clase, por ejemplo el descuento:

TArticulo = class
  public
  var
    ID:Integer;
    Nombre:String;
    Existencias:Real;
    Precio:Real;
    Descuento:Real;       // Nuevo campo
end;

Si guardamos los cambios y nos vamos al diagrama veremos el cambio en el gráfico:


Esto da una gran flexibilidad al programador al permitir dar toques aquí y allá sin que quede desincronizado el código fuente ni su diseño UML.

Eso sí, no todo va a ser perfecto. Si cogemos todas nuestras variables en diseño y las ponemos como privadas...



Al irnos al código fuente veremos que nos ha hecho esta pequeña chapuza:


Pero bueno, sólo hay que eliminar las palabras private sobrantes y una vez reagrupemos las variables no pasará nada, el diagrama seguirá igual. Pese a este pequeño defecto hay que reconocer que las ventajas de trabajar son enormes.

Cuando estamos diseñando en el editor de modelos podemos seleccionar una clase o una variable de la misma y guardar información respecto al autor, el alias y la versión:


Así podemos trabajar en equipo con otros programadores y analistas diseñando clases y modificando programas ya realizados apuntando siempre quien ha hecho la última modificación y la versión del mismo.

AÑADIENDO MÉTODOS A LA CLASE

A una clase también se le pueden añadir constructores, procedimientos y funciones de manera tan fácil como hemos creado las variables:


Si por ejemplo creamos un constructor, lo llamará automáticamente Create y lo pondrá como público:


Reflejándolo en el código fuente de manera instantánea:


CREANDO REGISTROS

Al igual que hemos creado clases utilizando el editor de modelos podemos crear registros (record) desde la paleta de herramientas:


Se llama structure porque estamos creando una estructura de datos (record). La estructura tiene un gráfico similar a la clase:


Y su código fuente también se crea automáticamente:


En los diseños de los registros también podemos añadir las nuevas características en el lenguaje que hemos visto en artículos anteriores, como pueden ser constructores, funciones y procedimientos.

CREANDO ASOCIACIONES ENTRE LOS ELEMENTOS

Al tener disponible un completo editor UML podemos establecer relaciones, asociaciones y dependencias entre los elementos gráficos insertados:


Tenemos todo tipo de asociaciones para crear una estructura jerárquica perfecta que relacione nuestras estructuras de datos y clase de una manera concisa:


Sólo es cuestión de cogerse un buen libro de UML y aprender como diseñar un sistema completo.

EXPORTANDO EL DISEÑO

El diseño que hemos generado en el Model View podemos exportarlo pulsando el editor con el botón derecho del ratón y seleccionando Export to Image:


Se abrirá esta ventana:


En esta ventana podemos modificar el ancho y alto de la imagen que va a exportar. Si pulsamos el botón Preview veremos una vista previa de la imagen que vamos a generar:


Sólo hay que pulsar el botón Save y podemos guardarlo como imagen JPG, BMP, GIF, etc.

En el próximo artículo veremos como generar la documentación de nuestro proyecto automáticamente.

Pruebas realizadas en RAD Studio 2007.

Pasando de Delphi 7 a RAD Studio 2007 (7)

LAS UNIDADES DE PRUEBAS

Este es otro de los puntos interesantes que incorpora por defecto RAD Studio 2007 y de hecho ya viene incorporado desde las versiones de Delphi 2005 en adelante. Una unidad de prueba (también conocido como test unitario o prueba unitaria) nos permite comprobar automáticamente el comportamiento de una clase aunque luego sigamos haciendo ampliaciones.

Para ello disponemos de la unidad DUnit.pas la cual está basada en JUnit del lenguaje de programación Java. DUnit incorpora funciones para realizar una serie de test a las clases de Delphi para Win32. En Delphi para .NET se utiliza la unidad NUnit.

Vamos a ver un ejemplo de cómo podemos realizar una prueba unitaria a una clase. Supongamos que tenemos una unidad llamada UFactura.pas que contiene una clase para calcular el total de una factura:

unit UFactura;

interface

type
  TFactura = class
  public
    BaseImponible, Iva, Total: Real;

  constructor Create( Importe: Real );
  procedure Calcular;
end;

implementation

constructor TFactura.Create( Importe: Real );
begin
 Iva := 16;
  BaseImponible := Importe;
  Calcular;
end;

procedure TFactura.Calcular;
begin
  Total := BaseImponible + BaseImponible * Iva / 100;
end;

end.

Para realizar una unidad de pruebas lo que hay que hacer realmente es crear un nuevo proyecto destinado exclusivamente para pruebas y añadir la unidad que vamos a testear.

Hay que seguir estos pasos:

1. En el proyecto actual que tengamos abierto mostramos el editor de código fuente (en vez del formulario) para que se pueda ver en la paleta de herramientas (Tool Palette). Abrimos la opción Unit test y hacemos doble clic sobre Test Project:


Aparecerá esta ventana:


Como se puede apreciar en la imagen, el campo Location lo que va a hacer es crear un nuevo proyecto en una carpeta llamada test dentro del la carpeta del proyecto actual. Esta carpeta la va a crear automáticamente.

2. Pulsamos el botón Next y aparecerá esta otra ventana:


En esta ventana se nos da a elegir si queremos que nos resultados los muestre en una ventana de Windows (GUI) en el modo consola (Console).

3. Lo dejamos como está y pulsamos el botón Finish. Después pulsamos el botón guardar.

Lo que hará será crear la nueva carpeta test y dentro meterá el nuevo proyecto creado:

4. Cerramos el proyecto actual y abrimos el proyecto de la carpeta test.

5. Añadimos al proyecto la unidad UFactura.pas que vamos a analizar (Project -> Add to proyect).

6. En la paleta de herramientas (Tool palette) hacemos doble clic sobre Test Case:


Nos aparecerá esta ventana:


7. Seleccionamos la unidad UFactura.pas y veremos abajo los métodos de la clase que queremos probar:


8. Lo dejamos como está y pulsamos el botón Finish.

Creará la siguiente unidad:

unit TestUFactura;
{
  Delphi DUnit Test Case
  ----------------------
  This unit contains a skeleton test case class generated by the Test Case Wizard.
  Modify the generated code to correctly setup and call the methods from the unit
  being tested.
}

interface

uses
  TestFramework, UFactura;

type
  // Test methods for class TFactura

  TestTFactura = class(TTestCase)
  strict private
    FFactura: TFactura;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestCalcular;
end;

implementation

procedure TestTFactura.SetUp;
begin
  FFactura := TFactura.Create;
end;

procedure TestTFactura.TearDown;
begin
  FFactura.Free;
  FFactura := nil;
end;

procedure TestTFactura.TestCalcular;
begin
  FFactura.Calcular;
  // TODO: Validate method results
end;

initialization
  // Register any test cases with the test runner
  RegisterTest(TestTFactura.Suite);
end.

Esta unidad contiene la clase TestTFactura que hereda de TTestCase la cual incorpora los siguiente métodos:

SetUp: Es el encargado de crear la clase que vamos a probar. En nuestro caso crearía una instancia de la clase TFactura:

procedure TestTFactura.SetUp;
begin
  FFactura := TFactura.Create( 100 );
end;

Originalmente me ha creado el constructor sin parámetros, por lo que yo le he añadido manualmente el parámetro 100, que es la base imponible de la factura que voy a probar.

TearDown: Elimina la instancia del objeto creado:

procedure TestTFactura.TearDown;
begin
  FFactura.Free;
  FFactura := nil;
end;

TestCalcular: Es el encargado de probar el procedimiento Calcular:

procedure TestTFactura.TestCalcular;
begin
  FFactura.Calcular;
  // TODO: Validate method results
end;

A este último procedimiento le vamos a añadir el comando CheckEquals que evalúa el resultado obtenido con el que esperábamos:

procedure TestTFactura.TestCalcular;
begin
  FFactura.Calcular;
  CheckEquals( 116, FFactura.Total, 'El Total de la factura es erroneo' ); // test de prueba
end;

El primer parámetro del procedimiento CheckEquals es el número que nosotros esperamos (Total factura = Base Imponible (100) + Iva (16) = 116). El segundo parámetro el valor resultante (la variable Total de la factura). El tercer parámetro es el mensaje que queremos que vea el usuario si hay un error en el resultado).

Si ejecutamos el programa nos aparecerá esta ventana:


Pulsamos el botón Run Selected Test (el botón play de color verde) y si todo ha ido bien nos mostrará todos los puntos de color verde:


Eso significa que el resultado es el esperado. Ahora vamos a estropear el método Calcular a cosa hecha para que nos devuelva un resultado erroneo:

procedure TFactura.Calcular;
begin
  Total := BaseImponible + BaseImponible * Iva / 100 + 1;
end;

Si volvemos a ejecutar el test nos aparecerá esto:


En este caso se ha producido un error en el test y si pulsamos abajo su error nos dirá que esperaba 116 y ha devuelto 117.

Esto es muy potente para evitar tener que realizar una batería de pruebas cada vez que tenemos que modificar de nuevo alguna clase.

Ahora supongamos que nos piden que la factura realice un descuento por pronto pago en la base imponible. Modificamos la factura para ello:

type
  TFactura = class
  public
    BaseImponible, Iva, Total, DtoPP: Real;
    
    constructor Create( Importe: Real );
    procedure Calcular;
  end;

implementation

constructor TFactura.Create( Importe: Real );
begin
  Iva := 16;
  DtoPP := 0;
  BaseImponible := Importe;
  Calcular;
end;

procedure TFactura.Calcular;
var
  ImporteNeto: Real;
begin
 ImporteNeto := BaseImponible - BaseImponible * DtoPP / 100;
  Total := ImporteNeto + ImporteNeto * Iva / 100;
end;

Esto es lo que más asusta a un programador: volver a retocar un programa que ya esta hecho y saber si lo anterior sigue funcionando correctamente. Con nuestra prueba unitaria sabemos que si la factura tiene una base imponible de 100 (sin el descuento) el resultado por fuerza tiene que ser 116.

Si volvemos a ejecutar el test lo dará correctamente pese a la ampliación que hemos hecho con el descuento. Lo que he aplicado aquí se puede hacer perfectamente con bases de datos comprobando si tenemos descuadres de decimales, si las fechas de emisión de los documentos son correctas a partir de la forma de pago, etc.

Aparte de la función CheckEquals también tenemos estas otras:

CheckNotEquals: Comprueba si el resultado no es igual (la inversa de CheckEquals).

Check: Evalua una condición booleana.

CheckNotNull: Comprueba si la referencia a un objeto o internaz no es nula (nil).

CheckNull: Comprueba si la referencia a un objeto o internaz es nula (nil).

CheckSame: Comprueba si dos referencias a objetos o interfaces apuntan al mismo objeto el memoria.

EqualsErrorMessage: comprueba si el mensaje de error devuelto por la aplicación es igual al que le pasamos como parámetro.

Fail: Comprueba si falla una rutina.

FailEquals: Comprueba si el fallo de una rutina es igual al que le pasamos como parámetro.

FailNoEquals: Comprueba si el fallo de una rutina no es igual al que le pasamos como parámetro.

FailNotSame: Comprueba si dos errores devueltos no son iguales.

NotEqualsErrorMessage: Comprueba si el mensaje de error que le pasamos como parámetro no es igual al que devuelve la aplicación.

NotSameErrorMessage: Comprueba si el error que le pasamos como parámetro no es igual al que devuelve la aplicación.

Con todas estas funciones cubrimos todas la posibilidades en la batería de pruebas que podemos someter a un programa.

En el próximo artículo seguiremos indagando sobre RAD Studio 2007.

Pruebas realizadas en RAD Studio 2007.