Tutorial: Crear y ejecutar una prueba unitaria de base de datos

Artículo
08/10/2011

En este tutorial, se crea una prueba unitaria de base de datos que comprueba el comportamiento de varios procedimientos almacenados. Las pruebas unitarias de base de datos se crean para ayudar a identificar defectos de código que podrían provocar un comportamiento incorrecto de la aplicación. Se pueden ejecutar pruebas unitarias de base de datos y pruebas de aplicación como parte de un conjunto automatizado de pruebas.

En este tutorial realizará las siguientes tareas:

Crear un script que contiene un esquema de base de datos
Crear un proyecto de base de datos e importar ese esquema
Implementar el proyecto de base de datos a un entorno de desarrollo aislado
Crear pruebas unitarias de base de datos
Definir la lógica de pruebas
Ejecutar pruebas unitarias de base de datos
Agregar una prueba unitaria negativa

Después de que una de las pruebas unitarias detecte un error en un procedimiento almacenado, se corrige ese error y se vuelve a ejecutar la prueba.

Requisitos previos

Para completar este tutorial, debe poder conectarse a un servidor de bases de datos en el que tenga los permisos necesarios para crear e implementar una base de datos. Para obtener más información, vea Permisos necesarios para las características de base de datos de Visual Studio.

Crear un script que contiene un esquema de base de datos

Para crear un script del que se puede importar un esquema

En el menú Archivo, elija Nuevo y, a continuación, haga clic en Archivo.

Aparece el cuadro de diálogo Nuevo archivo.
En la lista Categorías, haga clic en General si aún no está resaltada.
En la lista Plantillas, haga clic en Archivo SQL y, a continuación, haga clic en Abrir.

Se abre el editor de Transact-SQL.

Copie el código de Transact-SQL siguiente y péguelo en el editor de Transact-SQL.

PRINT N'Creating Sales...';
GO
CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo];
GO
PRINT N'Creating Sales.Customer...';
GO
CREATE TABLE [Sales].[Customer] (
    [CustomerID]   INT           IDENTITY (1, 1) NOT NULL,
    [CustomerName] NVARCHAR (40) NOT NULL,
    [YTDOrders]    INT           NOT NULL,
    [YTDSales]     INT           NOT NULL
);
GO
PRINT N'Creating Sales.Orders...';
GO
CREATE TABLE [Sales].[Orders] (
    [CustomerID] INT      NOT NULL,
    [OrderID]    INT      IDENTITY (1, 1) NOT NULL,
    [OrderDate]  DATETIME NOT NULL,
    [FilledDate] DATETIME NULL,
    [Status]     CHAR (1) NOT NULL,
    [Amount]     INT      NOT NULL
);
GO
PRINT N'Creating Sales.Def_Customer_YTDOrders...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDOrders] DEFAULT 0 FOR [YTDOrders];
GO
PRINT N'Creating Sales.Def_Customer_YTDSales...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDSales] DEFAULT 0 FOR [YTDSales];
GO
PRINT N'Creating Sales.Def_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_OrderDate] DEFAULT GetDate() FOR [OrderDate];
GO
PRINT N'Creating Sales.Def_Orders_Status...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_Status] DEFAULT 'O' FOR [Status];
GO
PRINT N'Creating Sales.PK_Customer_CustID...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [PK_Customer_CustID] PRIMARY KEY CLUSTERED ([CustomerID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.PK_Orders_OrderID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [PK_Orders_OrderID] PRIMARY KEY CLUSTERED ([OrderID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.FK_Orders_Customer_CustID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [FK_Orders_Customer_CustID] FOREIGN KEY ([CustomerID]) REFERENCES [Sales].[Customer] ([CustomerID]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating Sales.CK_Orders_FilledDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_FilledDate] CHECK ((FilledDate >= OrderDate) AND (FilledDate < '01/01/2020'));
GO
PRINT N'Creating Sales.CK_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_OrderDate] CHECK ((OrderDate > '01/01/2005') and (OrderDate < '01/01/2020'));
GO
PRINT N'Creating Sales.uspCancelOrder...';
GO
CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'X'
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspFillOrder...';
GO
CREATE PROCEDURE [Sales].[uspFillOrder]
@OrderID INT, @FilledDate DATETIME
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'F',
       [FilledDate] = @FilledDate
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspNewCustomer...';
GO
CREATE PROCEDURE [Sales].[uspNewCustomer]
@CustomerName NVARCHAR (40)
AS
BEGIN
INSERT INTO [Sales].[Customer] (CustomerName) VALUES (@CustomerName);
SELECT SCOPE_IDENTITY()
END
GO
PRINT N'Creating Sales.uspPlaceNewOrder...';
GO
CREATE PROCEDURE [Sales].[uspPlaceNewOrder]
@CustomerID INT, @Amount INT, @OrderDate DATETIME, @Status CHAR (1)='O'
AS
BEGIN
DECLARE @RC INT
BEGIN TRANSACTION
INSERT INTO [Sales].[Orders] (CustomerID, OrderDate, FilledDate, Status, Amount) 
     VALUES (@CustomerID, @OrderDate, NULL, @Status, @Amount)
SELECT @RC = SCOPE_IDENTITY();
UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders + @Amount
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
RETURN @RC
END
GO
CREATE PROCEDURE [Sales].[uspShowOrderDetails]
@CustomerID INT=0
AS
BEGIN
SELECT [C].[CustomerName], CONVERT(date, [O].[OrderDate]), CONVERT(date, [O].[FilledDate]), [O].[Status], [O].[Amount]
  FROM [Sales].[Customer] AS C
  INNER JOIN [Sales].[Orders] AS O
     ON [O].[CustomerID] = [C].[CustomerID]
  WHERE [C].[CustomerID] = @CustomerID
END
GO

En el menú Archivo, haga clic en Guardar SqlQuery_1.sql como.

Aparece el cuadro de diálogo Guardar archivo como.
En Nombre de objeto, escriba SampleImportScript.sql.

Puede guardar el archivo en cualquier ubicación del equipo. Anote la ubicación, porque debe utilizar este script en el procedimiento siguiente.
Haga clic en Guardar.
En el menú Archivo, haga clic en Cerrar solución.

A continuación, cree un proyecto de base de datos e importe el esquema a partir del script que ha creado.

Crear un proyecto de base de datos e importar ese esquema

Para crear un proyecto de base de datos

En el menú Archivo, elija Nuevo y, a continuación, haga clic en Proyecto.

Aparecerá el cuadro de diálogo Nuevo proyecto.
En Plantillas instaladas, expanda el nodo Base de datos y, a continuación, haga clic en SQL Server.

Nota

En cambio, si usa Visual Studio Professional, en Plantillas instaladas, expanda el nodo Base de datos, expanda el nodo SQL Server y, a continuación, haga clic en Avanzadas.
En la lista de plantillas, haga clic en Proyecto de base de datos de SQL Server 2008.

Nota

Si planea implementar su base de datos en una versión diferente de la base de datos, elija en su lugar la plantilla que corresponde al servidor de destino.
En Nombre, escriba SimpleUnitTestDB.
Active la casilla Crear directorio para la solución si aún no está activada.
Desactive la casilla Agregar al control de código fuente si aún no está desactivada y haga clic en Aceptar.

El proyecto de base de datos se crea y aparece en el Explorador de soluciones. A continuación, importará el esquema de base de datos desde un script.

Para importar un esquema de base de datos desde un script

En el menú Proyecto, haga clic en Importar script.
Haga clic en Siguiente después de leer la primera página del asistente.
Haga clic en Examinar e indique la ruta de acceso donde guardó el archivo SampleImportScript.sql.
Haga doble clic en el archivo SampleImportScript.sql y haga clic en Finalizar.

Se importa el script y los objetos que se definen en ese script se agregan al proyecto de base de datos.
Revise el resumen y, a continuación, haga clic en Finalizar para completar la operación.

Nota

El procedimiento Sales.uspFillOrder contiene un error de codificación intencionado que detectará y corregirá más adelante en este procedimiento.

Para examinar el proyecto resultante

En el Explorador de soluciones, expanda el nodo secundario Objetos de esquema.
Explore los subnodos situados bajo el nodo Objetos de esquema en la jerarquía.

El Explorador de soluciones contiene los archivos que definen los objetos de base de datos.
En el menú Ver, haga clic en Vista de esquema de la base de datos.
En Vista de esquema, expanda el nodo SimpleUnitTestDB.
Explore los subnodos situados bajo el nodo SimpleUnitTestDB en la jerarquía.

La Vista de esquema contiene los objetos definidos en los archivos que aparecen en el Explorador de soluciones.

Implementar en un entorno de desarrollo aislado

A continuación, implementará el proyecto para crear una base de datos que tiene el esquema importado, pero ningún dato. Esta base de datos se crea en un entorno de desarrollo aislado (o espacio aislado) para que pueda desarrollar y probar la base de datos sin que interfieran otros esfuerzos.

Para configurar y compilar el proyecto de base de datos

En el Explorador de soluciones, haga clic en el proyecto de base de datos SimpleUnitTestDB.
En el menú Proyecto, haga clic en Propiedades de SimpleUnitTestDB.

Aparecerá el cuadro de diálogo de propiedades del proyecto.
Haga clic en la pestaña Implementar.
En la lista Configurar valores de implementación para, haga clic en Mi entorno de desarrollo aislado. Configurando los valores del entorno de desarrollo aislado, se pueden utilizar valores de implementación diferentes que los que se utilizarán en los demás entornos, como el servidor de almacenamiento provisional o de producción.
En la lista Implementar acción, haga clic en Crear un script de implementación (.sql) e implementar en la base de datos.
En Configuración de la base de datos de destino, haga clic en Editar.

Aparece el cuadro de diálogo Propiedades de la conexión.
Establezca las propiedades de conexión para la base de datos que desea crear y, a continuación, haga clic en Aceptar.

En el cuadro Conexión de destino, aparecerá la cadena de conexión correcta.

Precaución

Debería crear la base de datos en un servidor de pruebas, en un servidor de desarrollo o en un equipo local. No se recomienda especificar el servidor de producción.
En Nombre de la base de datos de destino, escriba SimpleUnitTestDB.
Junto al archivo de configuración de implementación, haga clic en Editar.
Desactive la casilla Bloquear implementación incremental si puede dar lugar a pérdida de datos.

Nota

Para este tutorial, probará los procedimientos almacenados con respecto a una base de datos vacía que se implementa como parte de la prueba unitaria de base de datos. No es necesario conservar ninguno de los datos existentes, porque se van a probar los procedimientos almacenados en el entorno de desarrollo aislado.
En el menú Archivo, haga clic en Guardar todo.
En el menú Generar, haga clic en Generar solución.

Las propiedades que acaba de establecer determinan cómo se compila el script de implementación. El estado de la generación se muestra en la Ventana de salida; la última línea debe ser Generar: 1 correctos o actualizados.

Nota

Si la Ventana de salida no aparece, abra el menú Ver y haga clic en Salida.

Precaución
Debería crear la base de datos en un servidor de pruebas, en un servidor de desarrollo o en un equipo local. No se recomienda especificar el servidor de producción.

Para implementar el proyecto de base de datos

En el Explorador de soluciones, haga clic en el proyecto de base de datos SimpleUnitTestDB.
En el menú Compilar, haga clic en Implementar SimpleUnitTestDB.

Precaución

Debería ejecutar esta implementación en un servidor de pruebas, en un servidor de desarrollo o en un equipo local. No se recomienda especificar el servidor de producción.

El proyecto de base de datos se implementa en una nueva base de datos. El estado de la implementación se muestra en la Ventana de salida; la última línea debe ser Implementar: 1 correctos. Podría definir un plan de generación de datos para crear datos de prueba en la base de datos. En este tutorial, probará una base de datos muy simple para la que no es necesario generar datos.

Precaución
Debería ejecutar esta implementación en un servidor de pruebas, en un servidor de desarrollo o en un equipo local. No se recomienda especificar el servidor de producción.

Crear pruebas unitarias de base de datos

Para crear una prueba unitaria de base de datos para los procedimientos almacenados

En el menú Ver, haga clic en Vista de esquema.
En la Vista de esquema, expanda sucesivamente los nodos Esquemas, Sales, Programación y, por último, Procedimientos almacenados.
Haga clic con el botón secundario en el procedimiento almacenado uspNewCustomer y seleccione Crear pruebas unitarias.

Aparecerá el cuadro de diálogo Crear pruebas unitarias.
Active las casillas de los cinco procedimientos almacenados: Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrder y Sales.uspShowOrderDetails.
En Proyecto, haga clic en Crear un nuevo proyecto de prueba de Visual C#.
Acepte los nombres predeterminados del proyecto y la clase, y haga clic en Aceptar.

Aparecerá el cuadro de diálogo Configuración del proyecto 'TestProject1'.
En Ejecutar pruebas unitarias usando la siguiente conexión de datos, especifique una conexión a la base de datos que implementó anteriormente en este tutorial.

Nota

Si tiene que probar vistas o procedimientos almacenados con permisos restringidos, normalmente se especificaría esa conexión en este paso. A continuación, se especificaría la conexión secundaria, con permisos más amplios, para validar la prueba. Si tiene una conexión secundaria, debe agregar ese usuario al proyecto de base de datos y crear un inicio de sesión para ese usuario en el script anterior a la implementación.
En Implementación, active la casilla Implementar automáticamente el proyecto de base de datos antes de ejecutar pruebas unitarias.
En Proyecto de base de datos, haga clic en SimpleUnitTestDB.dbproj.
En Configuración de implementación:, haga clic en Depurar.

También podría generar los datos de prueba como parte de las pruebas unitarias de base de datos. En este tutorial, se omitirá ese paso porque las pruebas crearán sus propios datos.
Haga clic en Aceptar.

Se compila el proyecto de prueba y se muestra el Diseñador de pruebas unitarias de base de datos. A continuación, actualizará la lógica de pruebas en el script de Transact-SQL de las pruebas unitarias.

Definir la lógica de pruebas

Esta base de datos tan simple tiene dos tablas, Customer y Order. La base de datos se actualiza mediante el siguiente procedimiento almacenado:

uspNewCustomer: este procedimiento almacenado agrega un registro a la tabla Customer que establece en cero las columnas YTDSales y YTDOrders del cliente.
uspPlaceNewOrder: este procedimiento almacenado agrega un registro a la tabla Orders para el cliente especificado y actualiza el valor de YTDOrders en el registro correspondiente de la tabla Customer.
uspFillOrder: este procedimiento almacenado actualiza un registro en la tabla Orders cambiando el estado de 'O' a 'F' e incrementa el importe de YTDSales en el registro correspondiente de la tabla Customer.
uspCancelOrder: este procedimiento almacenado actualiza un registro en la tabla Orders cambiando el estado de 'O' a 'X' y disminuye el importe de YTDOrders en el registro correspondiente de la tabla Customer.
uspShowOrderDetails: este procedimiento almacenado combina la tabla Orders con la tabla Customer y muestra los registros de un cliente concreto.

Nota

En este ejemplo se muestra cómo crear una prueba unitaria de base de datos simple. En una base de datos real, podría sumar los importes totales de todos los pedidos cuyo estado fuera 'O' o 'F' de un cliente determinado. Los procedimientos den este tutorial tampoco contienen control de errores. Por ejemplo, no evitan que se llame a uspFillOrder para un pedido que ya se ha cursado.

Las pruebas suponen que la base de datos parte de un estado limpio. Creará pruebas que comprueban las siguientes condiciones:

uspNewCustomer: compruebe que la tabla Customer contiene una fila después de ejecutar el procedimiento almacenado.
uspPlaceNewOrder: para el cliente cuyo CustomerID es 1, realice un pedido por valor de $100. Compruebe que el importe de YTDOrders de ese cliente es 100 y que el importe de YTDSales es cero.
uspFillOrder: para el cliente cuyo CustomerID es 1, realice un pedido por valor de $50. Curse el pedido. Compruebe que el importe de YTDOrders y de YTDSales es 50.
uspShowOrderDetails: para el cliente cuyo CustomerID es 1, realice pedidos por valor de $100, $50 y $5. Compruebe que uspShowOrderDetails devuelve el número correcto de columnas y que el conjunto de resultados tiene la suma de comprobación esperada.

Nota

Para un conjunto completo de pruebas unitarias de base de datos, normalmente se comprueba que las demás columnas se han establecido correctamente. Para que este tutorial conserve un tamaño manejable, no describe cómo comprobar el comportamiento de uspCancelOrder.

Para escribir la prueba unitaria de base de datos de uspNewCustomer

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspNewCustomerTest y asegúrese de que Prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar el paso anterior, se puede crear el script de prueba para la acción correspondiente en la prueba unitaria.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

-- database unit test for Sales.uspNewCustomer
DECLARE @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @CustomerName = 'Fictitious Customer';

EXECUTE @RC = [Sales].[uspNewCustomer] @CustomerName;

SELECT * FROM [Sales].[Customer];

En el recuadro Condiciones de prueba, haga clic en la condición de prueba No concluyente y, a continuación, en Eliminar condición de prueba (x).
En el recuadro Condiciones de prueba, haga clic en Recuento de filas en la lista y, a continuación, haga clic en Agregar condición de prueba (+).
En la ventana Propiedades, establezca la propiedad Recuento de filas en 1.
En el menú Archivo, haga clic en Guardar todo.

A continuación, se define la lógica de prueba unitaria para uspPlaceNewOrder.

Para escribir la prueba unitaria de base de datos de uspPlaceNewOrder

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspPlaceNewOrderTest y asegúrese de que Prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar este paso, se puede crear el script de prueba para la acción correspondiente en la prueba unitaria.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

-- database unit test for Sales.uspPlaceNewOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- place an order for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

-- verify that the YTDOrders value is correct.
SELECT @RC = [YTDOrders] FROM [Sales].[Customer] WHERE [CustomerID] = @CustomerID

SELECT @RC AS RC

En el recuadro Condiciones de prueba, haga clic en la condición de prueba No concluyente y, a continuación, en Eliminar condición de prueba (x).
En el recuadro Condiciones de prueba, haga clic en la entrada Valor escalar de la lista y, a continuación, en Agregar condición de prueba (+).
En la ventana Propiedades, establezca la propiedad Valor esperado en 100.
En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspPlaceNewOrderTest y asegúrese de que Anterior a la prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar este paso, se pueden especificar instrucciones que cambien los datos al estado necesario para ejecutar la prueba. En este ejemplo, debe crear el registro del cliente para poder realizar un pedido.
Haga clic en la opciónHaga clic aquí para crear a fin de crear un script anterior a la prueba.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

/*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
-- Add a customer for this test with the name 'Fictitious Customer'
DECLARE @NewCustomerID AS INT, @CustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
   @CustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

En el menú Archivo, haga clic en Guardar todo.

A continuación, se crea la prueba unitaria para uspFillOrder.

Para escribir la prueba unitaria de base de datos de uspFillOrder

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspFillOrderTest y asegúrese de que Prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar este paso, se puede crear el script de prueba para la acción correspondiente en la prueba unitaria.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

-- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;
-- Get the most recently added order.
SELECT @OrderID = MAX([OrderID]) FROM [Sales].[Orders] WHERE [CustomerID] = @CustomerID;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspFillOrder] @OrderID, @FilledDate;

-- verify that the YTDOrders value is correct.
SELECT @RC = [YTDSales] FROM [Sales].[Customer] WHERE [CustomerID] = @CustomerID

SELECT @RC AS RC;

En el recuadro Condiciones de prueba, haga clic en la condición de prueba No concluyente y, a continuación, en Eliminar condición de prueba (x).
En el recuadro Condiciones de prueba, haga clic en la entrada Valor escalar de la lista y, a continuación, en Agregar condición de prueba (+).
En la ventana Propiedades, establezca la propiedad Valor esperado en 100.
En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspFillOrderTest y asegúrese de que Anterior a la prueba aparece seleccionado en la lista desplegable adyacente. Después de realizar este paso, se pueden especificar instrucciones que cambien los datos al estado necesario para ejecutar la prueba. En este ejemplo, debe crear el registro del cliente para poder realizar un pedido.
Haga clic en la opciónHaga clic aquí para crear a fin de crear un script anterior a la prueba.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

/*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place an order for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

COMMIT TRANSACTION

En el menú Archivo, haga clic en Guardar todo.

En este momento ya está preparado para ejecutar las pruebas.

Para escribir la prueba unitaria de base de datos de uspShowOrderDetails

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspShowOrderDetailsTest y asegúrese de que Prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar este paso, se puede crear el script de prueba para la acción correspondiente en la prueba unitaria.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

-- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspShowOrderDetails] @CustomerID;

SELECT @RC AS RC;

En el recuadro Condiciones de prueba, haga clic en la condición de prueba No concluyente y, a continuación, en Eliminar condición de prueba (x).
En el recuadro Condiciones de prueba, haga clic en la entrada Esquema esperado de la lista y, a continuación, en Agregar condición de prueba (+).
En la ventana Propiedades, en la propiedad Configuración, haga clic en el botón Examinar ('…').
En el cuadro de diálogo Configuración de expectedSchemaCondition1, especifique una conexión a su base de datos.
Haga clic en Recuperar.

Se ejecuta el cuerpo de Transact-SQL de la prueba unitaria. El esquema resultante aparece en el cuadro de diálogo. Dado que no se ejecutó el código anterior a la prueba, no se devuelve ningún dato. Como únicamente se está comprobando el esquema, y no los datos, es correcto así.
Haga clic en Aceptar.

El esquema esperado se almacena con la condición de prueba.
En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspShowOrderDetailsTest y asegúrese de que Anterior a la prueba aparece seleccionado en la lista desplegable adyacente. Después de realizar este paso, se pueden especificar instrucciones que cambien los datos al estado necesario para ejecutar la prueba. En este ejemplo, debe crear el registro del cliente para poder realizar un pedido.
Haga clic en la opciónHaga clic aquí para crear a fin de crear un script anterior a la prueba.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

/*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'FictitiousCustomer'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END


DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place 3 orders for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 100, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 50, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 5, @OrderDate, @Status;

COMMIT TRANSACTION

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspShowOrderDetailsTest y en Prueba en la lista adyacente.

Esto es necesario porque se desea aplicar la condición de suma de comprobación a la prueba, no antes de ella.
En el recuadro Condiciones de prueba, haga clic en Suma de comprobación de datos en la lista y, a continuación, haga clic en Agregar condición de prueba (+).
En la ventana Propiedades, en la propiedad Configuración, haga clic en el botón Examinar ('…').
En el cuadro de diálogo Configuración de checksumCondition1, especifique una conexión a su base de datos.

Reemplace el código de Transact-SQL en el cuadro de diálogo por el código siguiente:

BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END


DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;



-- place 3 orders for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 100, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 50, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 5, @OrderDate, @Status;


COMMIT TRANSACTION


-- database unit test for Sales.uspFillOrder
DECLARE @FilledDate AS DATETIME;
DECLARE @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspShowOrderDetails] @CustomerID;

SELECT @RC AS RC;

Este código combina el código de Transact-SQL anterior a la prueba con el código de Transact-SQL de la prueba en sí. Se necesitan ambos para devolver los mismos resultados que la prueba devolverá cuando se ejecute.

Haga clic en Recuperar.

Se ejecuta el código Transact-SQL que especificó y se calcula la suma de comprobación de los datos devueltos.
Haga clic en Aceptar.

La suma de comprobación calculada se almacena con la condición de prueba. La suma de comprobación esperada aparece en la columna Valor de la condición de prueba Suma de comprobación de datos.
En el menú Archivo, haga clic en Guardar todo.

En este momento ya está preparado para ejecutar las pruebas.

Ejecutar pruebas unitarias de base de datos

Para ejecutar las pruebas unitarias de base de datos

En el menú Prueba, seleccione Ventanas y, a continuación, haga clic en Vista de pruebas.
En la ventana Vista de pruebas, haga clic en Actualizar en la barra de herramientas para actualizar la lista de pruebas.

Las ventana Vista de pruebas muestra las pruebas que creó anteriormente en este tutorial y a las que agregó instrucciones de Transact-SQL y condiciones de prueba. La prueba que se denomina TestMethod1 está vacía y no se utiliza en esta tutorial.
Haga clic con el botón secundario en Sales_uspNewCustomerTest y seleccione Ejecutar selección.

Visual Studio utiliza el contexto privilegiado que especificó para conectarse a la base de datos y aplicar el plan de generación de datos. A continuación, Visual Studio cambia al contexto de ejecución antes de ejecutar el script de Transact-SQL en la prueba. Por último, Visual Studio evalúa los resultados del script de Transact-SQL respecto a los especificados en la condición de prueba y muestra un resultado de evaluación correcta o incorrecta en la ventana Resultados de pruebas.
Vea el resultado en la ventana Resultados de pruebas.

La prueba no tiene errores, lo que significa que la instrucción SELECT devuelve una fila cuando se ejecuta.

Repita el paso 3 para las pruebas Sales_uspPlaceNewOrderTest, Sales_uspFillOrderTest y Sales_uspShowOrderDetailsTest. Los resultados deben ser como sigue:

Pruebas	Resultado esperado
Sales_uspPlaceNewOrderTest	Sin errores
Sales_uspShowOrderDetailsTest	Sin errores
Sales_uspFillOrderTest	Presenta el siguiente error: "Error de la condición ScalarValueCondition (scalarValueCondition2): ResultSet fila 1, columna 1: los valores no coinciden, real '-100', esperado '100'". Este error se produce porque la definición del procedimiento almacenado contiene un error secundario.

A continuación, corregirá el error y volverá a ejecutar la prueba.

Para corregir el error de Sales.uspFillOrder

En Vista de esquema, haga doble clic en el procedimiento almacenado uspFillOrder para abrir su definición en el editor de Transact-SQL.

En la definición, busque la instrucción de Transact-SQL siguiente:

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID

Cambie la cláusula SET de la instrucción de forma que coincida con la siguiente:

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales + @Delta
    WHERE [CustomerID] = @CustomerID

En el menú Archivo, haga clic en Guardar uspFillOrder.proc.sql.
En la Vista de pruebas, haga clic con el botón secundario en Sales_uspFillOrderTest y seleccione Ejecutar selección.

La prueba se supera.

Agregar una prueba unitaria negativa

Se puede crear una prueba negativa para comprobar que una prueba no se supera cuando no se debe superar. Por ejemplo, si se intenta cancelar un pedido que ya se ha cursado, la prueba no se debe superar. En esta parte del tutorial, creará una prueba unitaria negativa para el procedimiento almacenado Sales.uspCancelOrder.

Para crear y comprobar una prueba negativa, debe realizar las siguientes tareas:

Actualizar el procedimiento almacenado para probar condiciones de error
Definir una nueva prueba unitaria
Modificar el código para que la prueba unitaria indique que se espera que no se supere
Ejecutar la prueba unitaria

Para actualizar el procedimiento almacenado

En la Vista de esquema, expanda sucesivamente los nodos SimpleUnitTestDB, Esquemas, Sales, Programación y Procedimientos almacenados. Haga doble clic en uspCancelOrder.

En el editor de Transact-SQL, actualice la definición del procedimiento para que coincida con el código siguiente:

CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
    DECLARE @Delta INT, @CustomerID INT, @PriorStatus CHAR(1)
    BEGIN TRANSACTION
        BEGIN TRY
            IF (NOT EXISTS(SELECT [CustomerID] from [Sales].[Orders] WHERE [OrderID] = @OrderID))
            BEGIN
                -- Specify WITH LOG option so that the error is
                -- written to the application log.
                RAISERROR( 'That order does not exist.', -- Message text
                           16, -- severity
                            1 -- state
                        ) WITH LOG;
            END

            SELECT @Delta = [Amount], @CustomerID = [CustomerID], @PriorStatus = [Status]
             FROM [Sales].[Orders] WHERE [OrderID] = @OrderID

            IF @PriorStatus <> 'O' 
            BEGIN
                -- Specify WITH LOG option so that the error is
                -- written to the application log.
                RAISERROR ( 'You can only cancel open orders.', -- Message text
                            16, -- Severity
                            1 -- State
                            ) WITH LOG;
            END
            ELSE
            BEGIN
                -- If we make it to here, then we can cancel the order. Update the status to 'X' first...
                UPDATE [Sales].[Orders]
                   SET [Status] = 'X'
                WHERE [OrderID] = @OrderID
                -- and then remove the amount from the YTDOrders for the customer
                UPDATE [Sales].[Customer]
                       SET
                           YTDOrders = YTDOrders - @Delta
                WHERE [CustomerID] = @CustomerID
                COMMIT TRANSACTION
                RETURN 1; -- indicate success
            END
        END TRY
        BEGIN CATCH
            DECLARE @ErrorMessage NVARCHAR(4000);
            DECLARE @ErrorSeverity INT;
            DECLARE @ErrorState INT;

            SELECT @ErrorMessage = ERROR_MESSAGE(),
                   @ErrorSeverity = ERROR_SEVERITY(),
                   @ErrorState = ERROR_STATE();

            ROLLBACK TRANSACTION
            -- Use RAISERROR inside the CATCH block to return
            -- error information about the original error that
            -- caused execution to jump to the CATCH block.
            RAISERROR (@ErrorMessage, -- Mesasge text
                       @ErrorSeverity, -- Severity
                       @ErrorState -- State
                      );
            RETURN 0; -- indicate failure
        END CATCH;
END

En el menú Archivo, haga clic en Guardar uspCancelOrder.proc.sql.
En el Explorador de soluciones, haga clic con el botón secundario en SimpleUnitTestDB y seleccione Implementar.

Se implementarán las actualizaciones del procedimiento almacenado uspCancelOrder. No ha cambiado ningún otro objeto, de modo que únicamente se actualiza ese procedimiento almacenado.

A continuación, defina la prueba unitaria asociada para este procedimiento.

Para escribir la prueba unitaria de base de datos de uspCancelOrder

En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspCancelOrderTest y asegúrese de que Prueba aparece seleccionado en la lista desplegable adyacente.

Después de realizar este paso, se puede crear el script de prueba para la acción correspondiente en la prueba unitaria.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

-- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;
-- Get the most recently added order.
SELECT @OrderID = MAX([OrderID]) FROM [Sales].[Orders] WHERE [CustomerID] = @CustomerID;

-- try to cancel an order for that customer that has already been filled
EXECUTE @RC = [Sales].[uspCancelOrder] @OrderID;

SELECT @RC AS RC;

En el recuadro Condiciones de prueba, haga clic en la condición de prueba No concluyente y, a continuación, en Eliminar condición de prueba (x).
En el recuadro Condiciones de prueba, haga clic en la entrada Valor escalar de la lista y, a continuación, en Agregar condición de prueba (+).
En la ventana Propiedades, establezca la propiedad Valor esperado en 0.
En la barra de navegación del Diseñador de pruebas unitarias de base de datos, haga clic en Sales_uspCancelOrderTest y asegúrese de que Anterior a la prueba aparece seleccionado en la lista desplegable adyacente. Después de realizar este paso, se pueden especificar instrucciones que cambien los datos al estado necesario para ejecutar la prueba. En este ejemplo, debe crear el registro del cliente para poder realizar un pedido.
Haga clic en la opciónHaga clic aquí para crear a fin de crear un script anterior a la prueba.

Actualice las instrucciones de Transact-SQL en el editor de Transact-SQL de forma que coincidan con las instrucciones siguientes:

/*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @FilledDate AS DATETIME, @Status AS CHAR (1), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
   @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
   @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place an order for that customer
EXECUTE @OrderID = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

-- fill the order for that customer
EXECUTE @RC = [Sales].[uspFillOrder] @OrderID, @FilledDate;

COMMIT TRANSACTION

En el menú Archivo, haga clic en Guardar todo.

En este momento ya está preparado para ejecutar las pruebas.

Para ejecutar las pruebas unitarias de base de datos

En la Vista de pruebas, haga clic con el botón secundario en Sales_uspCancelOrderTest y seleccione Ejecutar selección.
Vea el resultado en la ventana Resultados de pruebas.

La prueba no se supera y aparece el error siguiente:

Test method TestProject1.DatabaseUnitTests1.Sales_uspCancelOrderTest threw exception: System.Data.SqlClient.SqlException: You can only cancel open orders.

A continuación, modifique el código para indicar que se espera la excepción.

Para modificar el código para la prueba unitaria

En el Explorador de soluciones, expanda TestProject1, haga clic con el botón secundario en DatabaseUnitTests1.cs y seleccione Ver código.
En el editor de código, navegue hasta el método Sales_uspCancelOrderTest. Modifique los atributos del método de modo que coincidan con el siguiente código:
```
        [TestMethod(), ExpectedSqlException(Severity=16, MatchFirstError=false, State=1)]
        public void Sales_uspCancelOrderTest()
```
Especifica que espera ver una excepción de SQL concreta. Si lo desea, puede especificar un número de error concreto. Si no agrega este atributo, se producirá un error en la prueba unitaria y aparecerá un mensaje en la ventana Resultados de pruebas.
En el menú Archivo, haga clic en Guardar DatabaseUnitTests1.cs.

A continuación, repita la prueba unitaria para comprobar que no se supera, conforme a lo esperado.

Para ejecutar de nuevo las pruebas unitarias de base de datos

En la Vista de pruebas, haga clic con el botón secundario en Sales_uspCancelOrderTest y seleccione Ejecutar selección.
Vea el resultado en la ventana Resultados de pruebas.

La prueba se supera, lo que significa que se ha producido un error en el procedimiento cuando debía producirse.

Pasos siguientes

En un proyecto típico, definiría las pruebas unitarias adicionales para comprobar que todos los objetos de base de datos críticos funcionan correctamente. Una vez completado el conjunto de pruebas, éstas se protegerían en el control de versiones para compartirlas con el equipo.

Después de establecer una línea base, puede crear y modificar los objetos de base de datos y, a continuación, crear pruebas asociadas para comprobar si un cambio interrumpiría el comportamiento esperado.

Vea también

Tareas

Cómo: Crear una prueba unitaria de base de datos vacía

Cómo: Configurar la ejecución de las pruebas unitarias de base de datos

Conceptos

Crear y definir pruebas unitarias de base de datos

Comprobar código de base de datos mediante pruebas unitarias

Generar datos de prueba para bases de datos mediante generadores de datos

Compartir a través de

Tutorial: Crear y ejecutar una prueba unitaria de base de datos

Requisitos previos

Crear un script que contiene un esquema de base de datos

Para crear un script del que se puede importar un esquema

Crear un proyecto de base de datos e importar ese esquema

Para crear un proyecto de base de datos

Para importar un esquema de base de datos desde un script

Para examinar el proyecto resultante

Implementar en un entorno de desarrollo aislado

Para configurar y compilar el proyecto de base de datos

Para implementar el proyecto de base de datos

Crear pruebas unitarias de base de datos

Para crear una prueba unitaria de base de datos para los procedimientos almacenados

Definir la lógica de pruebas

Para escribir la prueba unitaria de base de datos de uspNewCustomer

Para escribir la prueba unitaria de base de datos de uspPlaceNewOrder

Para escribir la prueba unitaria de base de datos de uspFillOrder

Para escribir la prueba unitaria de base de datos de uspShowOrderDetails

Ejecutar pruebas unitarias de base de datos

Para ejecutar las pruebas unitarias de base de datos

Para corregir el error de Sales.uspFillOrder

Agregar una prueba unitaria negativa

Para actualizar el procedimiento almacenado

Para escribir la prueba unitaria de base de datos de uspCancelOrder

Para ejecutar las pruebas unitarias de base de datos

Para modificar el código para la prueba unitaria

Para ejecutar de nuevo las pruebas unitarias de base de datos

Pasos siguientes

Vea también

Tareas

Conceptos

Recursos adicionales