Tutorial: Compatibilidad del desarrollo de pruebas en primer lugar con la característica de generación a partir del uso

Artículo
08/10/2011

En este tema se muestra cómo se usa la característica Generar a partir del uso, que admite el desarrollo de pruebas en primer lugar.

El desarrollo de pruebas en primer lugar es un enfoque del diseño de software según el cual primero se escriben las pruebas unitarias en función de las especificaciones del producto y, a continuación, se escribe el código fuente necesario para que las pruebas se realicen correctamente. Visual Studio admite el desarrollo de pruebas en primer lugar mediante la generación de nuevos tipos y miembros en el código fuente la primera vez que se hace referencia a ellos en los casos de prueba, antes de definirlos.

Visual Studio genera los nuevos tipos y miembros con una interrupción mínima del flujo de trabajo. Puede crear código auxiliar para tipos, métodos, propiedades, campos o constructores sin dejar la posición en la que se encuentra en el código. Al abrir un cuadro de diálogo para especificar las opciones de generación de tipos, el foco vuelve inmediatamente al archivo abierto cuando se cierra el cuadro de diálogo.

La característica Generar a partir del uso se puede usar con marcos de pruebas que se integran con Visual Studio. En este tema se muestra el marco de pruebas unitarias de Microsoft.

Nota

Este tutorial se escribió pensando en la configuración de desarrollo de Visual Basic o Visual C#. No obstante, el tutorial también funcionará con otras configuraciones.

Para cambiar a los valores recomendados, puede usar este procedimiento: en el menú Herramientas, haga clic en Importar y exportar configuraciones. En la primera página del Asistente para importar y exportar configuraciones, haga clic en Restablecer todas las configuraciones. En la página Elija una colección predeterminada de configuraciones, haga clic en Configuración de desarrollo de Visual Basic o Configuración de desarrollo de Visual C#.

Para crear un proyecto de biblioteca de clases de Windows y un proyecto de prueba

En Visual C# o Visual Basic, cree un proyecto de biblioteca de clases de Windows. Denomínelo GFUDemo_VB o GFUDemo_CS, dependiendo del lenguaje que esté usando.
En el Explorador de soluciones, haga clic con el botón secundario del mouse en el icono de la solución de la parte superior, elija Agregar y, a continuación, haga clic en Nuevo proyecto. En el cuadro de diálogo Nuevo proyecto, en el recuadro Tipos de proyecto de la izquierda, haga clic en Prueba.
En el recuadro Plantillas, haga clic en Proyecto de prueba y acepte el nombre predeterminado, TestProject1. En la siguiente ilustración se muestra el cuadro de diálogo cuando aparece en Visual C#. En Visual Basic, el cuadro de diálogo es similar.

Cuadro de diálogo Nuevo proyecto
Haga clic en Aceptar para cerrar el cuadro de diálogo Nuevo proyecto. Ahora ya está listo para empezar a escribir pruebas.

Para generar una nueva clase a partir de una prueba unitaria

El proyecto de prueba contiene un archivo que se denomina UnitTest1. Haga doble clic en este archivo en el Explorador de soluciones para abrirlo en el Editor de código. Se han generado una clase de prueba y un método de prueba.
Busque la declaración de la clase UnitTest1 y cámbiele el nombre a AutomobileTest. En C#, si hay un constructor UnitTest1(), cámbiele el nombre a AutomobileTest().

Nota

IntelliSense proporciona ahora dos alternativas para completar las instrucciones de IntelliSense: el modo de finalización y el modo de sugerencia. Emplee el modo de sugerencia en aquellas situaciones en que las clases y los miembros se usen antes de definirlos. Cuando se abre una ventana de IntelliSense, puede presionar CTRL+ALT+BARRA ESPACIADORA para alternar entre el modo de finalización y el modo de sugerencia. Para obtener más información, vea Lista de miembros. El modo de sugerencia le será útil cuando escriba Automobile en el paso siguiente.
Busque el método TestMethod1() y cambie su nombre a DefaultAutomobileIsInitializedCorrectly(). En este método, cree una nueva instancia de una clase denominada Automobile, tal como se muestra en las siguientes ilustraciones. Aparecerá un subrayado ondulado que indica un error en tiempo de compilación, así como una etiqueta inteligente bajo el nombre del tipo. La ubicación exacta de la etiqueta inteligente varía, dependiendo de si está usando Visual Basic o Visual C#.

Visual Basic

Visual C#
Coloque el puntero del mouse sobre la etiqueta inteligente para ver un mensaje de error que indica que todavía no se ha definido ningún tipo denominado Automobile. Haga clic en la etiqueta inteligente o presione CTRL+. (CTRL+punto) para abrir el menú contextual Generar a partir del uso, como se muestra en las siguientes ilustraciones.

Visual Basic

Visual C#
Ahora tiene dos opciones. Podría hacer clic en Generar 'Class Automobile' para crear un nuevo archivo en su proyecto de prueba y llenarlo con una clase vacía denominada Automobile. Es una manera rápida de crear una nueva clase en un nuevo archivo que tenga modificadores de acceso predeterminados en el proyecto actual. También puede hacer clic en Generar nuevo tipo para abrir el cuadro de diálogo Generar nuevo tipo. Esto proporciona opciones como colocar la clase en un archivo existente y agregar el archivo a otro proyecto.

Haga clic en Generar nuevo tipo para abrir el cuadro de diálogo Generar nuevo tipo, que se muestra en la siguiente ilustración. En la Lista de proyectos, haga clic en GFUDemo_VB o GFUDemo_CS para indicar a Visual Studio que agregue el archivo al proyecto de código fuente en lugar de al proyecto de prueba.

Cuadro de diálogo Generar nuevo tipo
Haga clic en Aceptar para cerrar el cuadro de diálogo y crear el nuevo archivo.
En el Explorador de soluciones, busque bajo el nodo del proyecto GFUDemo_CS o GFUDemo_VB para comprobar si contiene el nuevo archivo Automobile.vb o Automobile.cs. En el Editor de código, el foco todavía se encuentra en AutomobileTest.DefaultAutomobileIsInitializedCorrectly. Puede continuar escribiendo su prueba prácticamente sin interrupciones.

Para generar código auxiliar de propiedad

Supongamos que la especificación del producto indica que la clase Automobile tiene dos propiedades públicas denominadas Model y TopSpeed. El constructor predeterminado debe inicializar estas propiedades con los valores predeterminados "Not specified" y -1. La siguiente prueba unitaria comprobará que el constructor predeterminado establece las propiedades en los valores predeterminados correctos.

Agregue la siguiente línea de código a DefaultAutomobileIsInitializedCorrectly.
```
Assert.IsTrue((myAuto.Model = "Not specified") And (myAuto.TopSpeed = -1))
```
```
Assert.IsTrue((myAuto.Model == "Not specified") && (myAuto.TopSpeed == -1));
```
Dado que el código hace referencia a dos propiedades sin definir en Automobile, aparece una etiqueta inteligente. Haga clic en la etiqueta inteligente correspondiente a Model y, a continuación, haga clic en Generar código auxiliar de propiedad. Genere también código auxiliar de propiedad para la propiedad TopSpeed.

En la clase Automobile, los tipos de las nuevas propiedades se deducen correctamente del contexto.

El menú contextual de la etiqueta inteligente se muestra en la siguiente ilustración.

Visual Basic

Visual C#

Para buscar el código fuente

Use la característica Navegar a para navegar al archivo de código fuente Automobile.cs o Automobile.vb, donde podrá comprobar si se han generado las nuevas propiedades.

La característica Navegar a permite escribir rápidamente una cadena de texto, como un nombre de tipo o parte de un nombre, e ir a la ubicación deseada haciendo clic en el elemento en la lista de resultados.

Abra el cuadro de diálogo Navegar a haciendo clic en el Editor de código y presionando CTRL+, (CTRL+coma). En el cuadro de texto, escriba automobile. En la lista, haga clic en la clase Automobile y, a continuación, en Aceptar.

La ventana Navegar a se muestra en la siguiente ilustración.

Navegar a ventana

Para generar código auxiliar para un nuevo constructor

En este método de prueba, generará código auxiliar de constructor que inicializará las propiedades TopSpeed y Model para que tengan los valores que especifique. Después, agregará más código para completar la prueba. Agregue el método de prueba adicional siguiente a la clase AutomobileTest.

<TestMethod()> Public Sub AutomobileWithModelNameCanStart()
    Dim model As String = "Contoso"
    Dim topSpeed As Integer = 199
    Dim myAuto As New Automobile(model, topSpeed)
End Sub

[TestMethod]
public void AutomobileWithModelNameCanStart()
{
    string model = "Contoso";
    int topSpeed = 199;
    Automobile myAuto = new Automobile(model, topSpeed);
}

Haga clic en la etiqueta inteligente bajo el nuevo constructor de clase y, a continuación, haga clic en Generar código auxiliar de constructor. En el archivo de clase Automobile, observe que el nuevo constructor ha examinado los nombres de las variables locales que se usan en la llamada de constructor, ha encontrado propiedades que tienen los mismos nombres en la clase Automobile y ha proporcionado código en el cuerpo del constructor para almacenar los valores de los argumentos en las propiedades Model y TopSpeed. (En Visual Basic, los campos _topSpeed y _model del nuevo constructor son implícitamente los campos de respaldo definidos para las propiedades Model y TopSpeed).
Después de generar el nuevo constructor, aparece un subrayado ondulado bajo la llamada al constructor predeterminado en DefaultAutomobileIsInitializedCorrectly. El mensaje de error indica que la clase Automobile no tiene ningún constructor que no use ningún argumento. Para generar un constructor predeterminado explícito que no tenga parámetros, haga clic en la etiqueta inteligente y, a continuación, haga clic en Generar código auxiliar de constructor.

Para generar código auxiliar para un método

Supongamos que la especificación indica que una nueva clase Automobile se puede poner en estado de ejecución si sus propiedades TopSpeed y Model están establecidas en un valor distinto del predeterminado. Agregue las líneas siguientes al método AutomobileWithModelNameCanStart.
```
myAuto.Start()
Assert.IsTrue(myAuto.IsRunning = True)
```
```
myAuto.Start();
Assert.IsTrue(myAuto.IsRunning == true);
```
Haga clic en la etiqueta inteligente para la llamada al método myAuto.Start y, a continuación, haga clic en Generar código auxiliar del método.

Haga clic en la etiqueta inteligente correspondiente a la propiedad IsRunning y, a continuación, haga clic en Generar código auxiliar de propiedad. Ahora, la clase Automobile contiene el código siguiente.

Public Class Automobile
    Sub New(ByVal model As String, ByVal topSpeed As Integer)
        _model = model
        _topSpeed = topSpeed
    End Sub
    Sub New()
        ' TODO: Complete member initialization 
    End Sub

    Property Model() As String
    Property TopSpeed As Integer
    Property IsRunning As Boolean
    Sub Start()
        Throw New NotImplementedException
    End Sub
End Class

public class Automobile
{
    public string Model { get; set; }
    public int TopSpeed { get; set; }

    public Automobile(string model, int topSpeed)
    {
        this.Model = model;
        this.TopSpeed = topSpeed;
    }

    public Automobile()
    {
        // TODO: Complete member initialization
    }

    public void Start()
    {
        throw new NotImplementedException();
    }

    public bool IsRunning { get; set; }
}

Para ejecutar las pruebas

En el menú Prueba, elija Ejecutar y, a continuación, haga clic en Todas las pruebas de la solución. Este comando ejecuta todas las pruebas de todos los marcos de pruebas que se escriban para la solución actual.

En este caso, hay dos pruebas y ambas finalizan con errores, tal y como se esperaba. La prueba DefaultAutomobileIsInitializedCorrectly no se supera porque la condición Assert.IsTrue devuelve False. La prueba AutomobileWithModelNameCanStart no se supera porque el método Start de la clase Automobile inicia una excepción.

La ventana Resultados de pruebas se muestra en la siguiente ilustración.

Ventana Resultados de pruebas
En la ventana Resultados de pruebas, haga doble clic en cada una de las filas de resultados de pruebas para ir a la ubicación de cada uno de los errores de pruebas.

Nota

Si al hacer doble clic, no se lo desplaza hasta el error de pruebas del código, puede habilitar esta característica mediante el procedimiento siguiente: en el menú Herramientas, haga clic en Opciones, expanda Herramientas de prueba y haga clic en Ejecución de prueba. Active la casilla Al hacer clic en el resultado de una prueba unitaria que sea Error o No concluyente, se muestra el punto de error en la prueba.

Para implementar el código fuente

Agregue el siguiente código al constructor predeterminado para que las propiedades Model, TopSpeed e IsRunning se inicialicen en sus valores predeterminados correctos: "Not specified", -1 y True (true).
```
Sub New()
    Model = "Not specified"
    TopSpeed = -1
    IsRunning = True
End Sub
```
```
public Automobile()
{
    this.Model = "Not specified";
    this.TopSpeed = -1;
    this.IsRunning = true;
}
```

Cuando se llama al método Start, debería establecer la marca IsRunning en True únicamente si las propiedades Model o TopSpeed están establecidas en un valor distinto del predeterminado. Quite NotImplementedException del cuerpo del método y agregue el siguiente código.

Sub Start()
    If Model <> "Not specified" Or TopSpeed <> -1 Then
        IsRunning = True
    Else
        IsRunning = False
    End If
End Sub

public void Start()
{
    if (this.Model != "Not specified" || this.TopSpeed != -1)
        this.IsRunning = true;
    else
        this.IsRunning = false;
}

Para volver a ejecutar las pruebas

En el menú Prueba, elija Ejecutar y, a continuación, haga clic en Todas las pruebas de la solución. Esta vez las pruebas se realizan correctamente. La ventana Resultados de pruebas se muestra en la siguiente ilustración.

Ventana Resultados de pruebas

Vea también