This article talks about core concepts of test-driven database development followed by creating simple SQL unit tests with tSQLt based on this approach.

本文讨论测试驱动的数据库开发的核心概念，然后基于此方法使用tSQLt创建简单SQL单元测试。

The conventional SQL unit testing has been around since long while test-driven database development has not also been introduced yesterday, however, switching to this testing methodology offers pure unit testing experience with a lot more features and flexibility as compared to its counterpart.

常规SQL单元测试已经存在很长时间了，而昨天还没有引入测试驱动的数据库开发，但是，切换到这种测试方法可以提供纯净的单元测试体验，与之相比，它具有更多的功能和灵活性。

Let us get introduced with test-driven database development first and please be prepared to switch to it if you are not already using it and you are happy to do so.

首先让我们介绍一下测试驱动的数据库开发，如果您还没有使用它并且很高兴这样做，请准备好切换到它。

关于测试驱动的数据库开发 (About test-driven database development )

It is better to define test-driven database development first, so that it becomes easier to explore it further.

最好先定义测试驱动的数据库开发，以便更轻松地进行探索。

简单定义 (Simple Definition )

The method in which unit tests drive the database development process is called test-driven database development or TDDD.

单元测试驱动数据库开发过程的方法称为测试驱动数据库开发或TDDD。

替代定义 (Alternative Definition )

The method of creating database objects based on creating and running their unit tests first is called test-driven database development or TDDD.

基于首先创建并运行其单元测试的数据库对象的方法称为测试驱动的数据库开发或TDDD。

TDDD：开发还是测试？ (TDDD: Development or testing?)

I know, for the first time learners, the above definitions do not give much information about test-driven database development and on the top of that it is not still not clear whether we are talking about database development or database unit testing?

我知道，对于初学者来说，以上定义并未提供太多有关测试驱动的数据库开发的信息，最重要的是，我们是否在谈论数据库开发或数据库单元测试尚不清楚。

The short answer is, both!

简短的答案是，两者！

Yes, it is basically SQL unit testing followed by database development unlike database development followed by SQL unit testing.

是的，它基本上是SQL单元测试，然后是数据库开发，而不是数据库开发，然后是SQL单元测试。

I may have added more confusion now. So it’s time to clear the confusion now.

我现在可能更加困惑了。 因此，现在该清除混乱了。

测试优先 (Test first approach)

TDDD is basically a test first approach in which database development rely on unit testing to begin and take the control.

TDDD基本上是一种测试优先的方法，其中数据库开发依赖于单元测试来开始和控制。

The best way to understand this is to compare conventional unit testing with test-driven database development.

理解这一点的最好方法是将传统的单元测试与测试驱动的数据库开发进行比较。

常规与测试驱动SQL开发 (Conventional vs Test-driven SQL development )

Please see a simple comparison between conventional SQL unit testing and TDDD

请查看常规SQL单元测试和TDDD之间的简单比较

Conventional SQL unit testing	Test-driven database development
Create database object Write database unit test to check object exists or not Run database unit test	Create database unit test to check if potential object exists or not Run the unit test which will fail first Add database object Run the unit test which will pass now

常规SQL单元测试	测试驱动的数据库开发
创建数据库对象 编写数据库单元测试以检查对象是否存在 运行数据库单元测试	创建数据库单元测试以检查是否存在潜在的对象 运行将首先失败的单元测试 添加数据库对象 运行将立即通过的单元测试

A more comprehensive comparison between both methodologies is as follows:

两种方法之间的更全面比较如下：

Conventional SQL unit testing	Test-driven database development
Create database object Add desired functionality to the object Create unit test to check if object functions properly Run the database unit test to see it passing or failing	Create unit test to check if potential object exists or not Run unit test which fails since the object does not exist Create object and rerun the unit test which should pass now Create another unit test to check if object functions properly Run the unit test which will fail now Modify the database object to function properly and rerun the unit test which should pass now

常规SQL单元测试	测试驱动的数据库开发
创建数据库对象 向对象添加所需的功能 创建单元测试以检查对象是否正常运行 运行数据库单元测试以查看其通过或失败	创建单元测试以检查是否存在潜在的对象 运行单元测试失败，因为该对象不存在 创建对象并重新运行现在应该通过的单元测试 创建另一个单元测试以检查对象是否正常运行 运行现在将失败的单元测试 修改数据库对象以使其正常运行，然后重新运行现在应该通过的单元测试

The above points become more understandable as you move to the next sections of this article.

当您转到本文的下一部分时，以上几点将变得更加容易理解。

To know more about conventional SQL unit testing please refer to the article, “Conventional SQL Unit Testing with tSQLt in Simple Words”

要了解有关常规SQL单元测试的更多信息，请参阅文章“ 简单单词中使用tSQLt的常规SQL单元测试 ”

测试驱动的数据库开发的好处 (Benefits of test-driven database development )

There are quite a number of benefits of using test-driven database development but we are only going to mention some major benefits of TDDD to highlight its importance.

使用测试驱动的数据库开发有很多好处，但是我们仅要提及TDDD的一些主要好处，以突出其重要性。

业务逻辑封装 (Business Logic Encapsulation)

One of the most outstanding benefits of test-driven database development is the encapsulation of business logic in the unit tests rather than database objects.

测试驱动的数据库开发最显着的好处之一就是将业务逻辑封装在单元测试中，而不是数据库对象中。

For example, a business requirement for end user to be able to add new book to the library system should be met by writing a unit test(s) to ensure the database object responsible for adding the new book to the library system does its job properly.

例如，应该通过编写一个单元测试来满足最终用户能够将新书添加到图书馆系统的业务要求，以确保负责将新书添加到图书馆系统的数据库对象能够正常工作。

In simple words we look for the unit tests rather than database objects to see if the objects are doing their job properly or not and in this way business logic is concealed in unit tests rather than objects.

用简单的话来说，我们寻找的是单元测试而不是数据库对象，以查看对象是否在正确地完成工作，这样，在单元测试而不是对象中隐藏了业务逻辑。

完整的测试范围 (Full Test Coverage)

Test-driven database development gives you full test coverage as compared to conventional database unit testing.

与传统的数据库单元测试相比，测试驱动的数据库开发为您提供了完整的测试范围。

Full test coverage means all our unit tests are covering all the database objects which are responsible for meeting business or technical requirements.

全面的测试范围意味着我们所有的单元测试都覆盖了负责满足业务或技术要求的所有数据库对象。

早期错误检测 (Early Bug Detection)

Test-driven database development helps in early bug detection since SQL unit tests are in the front line of writing database object code.

测试驱动的数据库开发有助于早期发现错误，因为SQL单元测试位于编写数据库对象代码的第一线。

In other words, since all the unit tests are written first and are not considered correct until they pass so it helps in early bug detection.

换句话说，由于所有单元测试都是首先编写的，并且直到通过后才被认为是正确的，因此有助于早期发现错误。

以需求为中心的开发 (Requirements Focussed Development)

Another very handy benefit of test-driven database development is that, it only requires you to develop what is required by business.

测试驱动的数据库开发的另一个非常方便的好处是，只需要您开发业务所需的内容即可。

Since your database objects are totally based on unit tests and your unit tests are only written to meet the business requirements so in this way un-necessary database coding can be avoided and this saves a lot of time and effort.

由于您的数据库对象完全基于单元测试，并且仅根据业务需求编写单元测试，因此，可以避免不必要的数据库编码，从而节省了大量时间和精力。

For example in order to meet a business requirement to add new book to the library system does not require you to provide search functionality as well since you are only concerned with what is required.

例如，为了满足将新书添加到图书馆系统的业务需求，由于您只关心所需内容，因此也不需要您提供搜索功能。

实施测试驱动的数据库开发 (Implementing Test-driven database development )

Let us now jump to implement test-driven database development with tSQLt unit testing taking into account a simple scenario.

现在让我们跳到使用tSQLt单元测试来实现测试驱动的数据库开发，同时考虑一个简单的场景。

为什么使用测试驱动的数据库开发来开发tSQLt？ (Why tSQLt with test-driven database development?)

tSQLt is one of the most advanced SQL unit testing frameworks and it supports test-driven database development by default.

tSQLt是最先进SQL单元测试框架之一，默认情况下它支持测试驱动的数据库开发。

tSQLt has been written in such a way that it is by design, facilitates test first approach and this is what you are going to experience in this section.

tSQLt的编写方式是设计使然，有助于测试优先方法，这就是您在本节中要体验的内容。

• Note:注意：tSQLt – A Forgotten Treasure in Database Unit TestingtSQLt –数据库单元测试中的遗忘宝藏

先决条件 (Pre-requisites)

This article assumes that readers have general understanding of database unit testing and T-SQL and can comfortably write simple database scripts.

本文假定读者对数据库单元测试和T-SQL有一般的了解，并且可以轻松编写简单的数据库脚本。

This article also assumes that readers are familiar with tSQLt unit testing framework.

本文还假定读者熟悉tSQLt单元测试框架。

设置样本数据库 (Setup sample database)

We are creating a sample database which consists of the following tables:

我们正在创建一个包含以下表格的示例数据库：

1. Author 作者
2. Article 文章

Let us create a sample database SQLDevArticlesV3 by running the following script:

让我们通过运行以下脚本来创建示例数据库SQLDevArticlesV3：

-- 1 Create SQLDevArticlesV3 database
CREATE DATABASE SQLDevArticlesV3;
GOUSE SQLDevArticlesV3;
GO-- 2 Create author table
CREATE TABLE [dbo].[Author] ([AuthorId]         INT           IDENTITY (1, 1) NOT NULL,[Name]             VARCHAR (40)  NOT NULL,[RegistrationDate] DATETIME2 (7) NULL
);-- 3 Create article tables
CREATE TABLE [dbo].[Article] ([ArticleId]      INT           IDENTITY (1, 1) NOT NULL,[Title]          VARCHAR (300) NOT NULL,[Published_Date] DATETIME2 (7) NOT NULL
);-- 4 Populate author table
SET IDENTITY_INSERT [dbo].[Author] ON
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate]) VALUES (1, N'Asif', N'2018-01-01 00:00:00')
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate]) VALUES (2, N'Peter', N'2018-02-01 00:00:00')
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate]) VALUES (3, N'Sarah', N'2018-03-02 00:00:00')
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate]) VALUES (4, N'Adil', N'2018-04-02 00:00:00')
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate]) VALUES (5, N'Sam', N'2019-01-01 00:00:00')
SET IDENTITY_INSERT [dbo].[Author] OFF-- 5 Populate article table
SET IDENTITY_INSERT [dbo].[Article] ON
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date]) VALUES (1, N'Fundamentals of Database Programming', N'2018-01-02 00:00:00')
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date]) VALUES (2, N'Advanced Database Programming', N'2018-01-03 00:00:00')
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date]) VALUES (3, N'Understanding SQL Stored Procedures ', N'2018-02-02 00:00:00')
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date]) VALUES (4, N'Database Design Concepts', N'2018-03-02 00:00:00')
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date]) VALUES (5, N'Power BI Desktop Fundamentals', N'2019-01-02 00:00:00')
SET IDENTITY_INSERT [dbo].[Article] OFF;
GO

As a result of running the above script you see the sample database getting created.

运行上述脚本的结果是，您看到示例数据库已创建。

安装tSQLt单元测试框架 (Install tSQLt unit testing framework)

Please download the tSQLt unit testing framework form the tSQLt.org.

请下载tSQLt单元测试框架的形式tSQLt.org 。

Please refer to Conventional SQL Unit Testing with tSQLt in Simple Words article for better understanding of how to install the tSQLt unit testing framework if you have not installed it before.

如果您以前没有安装过tSQLt单元测试框架，请参阅“简单单词”中的“使用tSQLt进行常规SQL单元测试”文章，以更好地了解如何安装tSQLt单元测试框架。

Open tSQLt.class.sql file in SSMS (SQL Server Management Studio) and Run tSQL.class.sql script against the sample database SQLDevArticlesV3.

在SSMS （SQL Server Management Studio）中打开tSQLt.class.sql文件，然后对示例数据库SQLDevArticlesV3运行tSQL.class.sql脚本。

So, sample database has been setup and the tSQLt unit testing framework has also been added to it which means we are good to go.

因此，已经建立了示例数据库，并且还添加了tSQLt单元测试框架，这意味着我们很高兴。

业务需求 (Business requirement )

A business requirement stating that the end user should be able to add a new article to the database has just arrived.

说明最终用户应该能够向数据库中添加新文章的业务需求已经到来。

创建测试类（ArticleTests） (Create test class (ArticleTests))

In order to start writing tSQLt unit tests you have to create a suitable test class which can be easily created a by creating a schema in the database under test.

为了开始编写tSQLt单元测试，您必须创建一个合适的测试类，可以通过在被测数据库中创建模式来轻松创建一个合适的测试类。

Create ArticleTests schema (test class) as follows:

创建ArticleTests模式（测试类），如下所示：

USE SQLDevArticlesV3;
GO-- Creating unit test calss ArticleTests
CREATE SCHEMA [ArticleTests]
Authorization dbo
GO
EXECUTE sp_addextendedproperty @name='tSQLt.TestClass',@value=1,@level0type='SCHEMA',@level0name='ArticleTests'

成为需求焦点 (Be requirements focus)

The first step in test-driven database development is to just focus on meeting the requirement only by relying on unit tests more than the objects themselves.

测试驱动的数据库开发的第一步是仅依靠单元测试而不是对象本身来专注于满足需求。

This means we have to come up with a potential database object AddArticle.

这意味着我们必须提出一个潜在的数据库对象AddArticle。

创建SQL单元测试以检查对象是否存在 (Create SQL unit test to check object exists)

Test-driven database development demands first to write a unit test to check if potential object exists or not.

测试驱动的数据库开发要求首先编写一个单元测试，以检查是否存在潜在的对象 存在与否。

Write first unit test to see object exists or not as follows:

编写第一个单元测试以查看对象是否存在，如下所示：

CREATE PROCEDURE ArticleTests.[test to check AddArticle exists]
AS
BEGIN--Assemble--Act--AssertEXEC tSQLt.AssertObjectExists @ObjectName = N'AddArticle'
END;
GO

运行单元测试以检查对象是否存在 (Run unit test to check object exists)

This is the tricky bit we know the object does not exist then why we are running the unit test? The answer is to comply with test-driven database development in which unit tests drive the process and they must pass to proceed further.

这是棘手的一点，我们知道对象不存在，那么为什么我们要运行单元测试？ 答案是要遵循测试驱动的数据库开发，在该开发中，单元测试将驱动该过程，并且必须通过以进一步进行。

Run all the unit test by running all the unit tests for the test class ArticleTests as follows:

通过运行测试类ArticleTests的所有单元测试来运行所有单元测试，如下所示：

-- Run all unit tests related to ArticleTest test class
EXEC tsqlt.RunTestClass "ArticleTests"

It is obvious from the test class output that the unit test to check object exists has failed:

从测试类输出中可以明显看出，检查对象是否存在的单元测试已失败：

创建数据库对象（ArticleTests） (Create database object (ArticleTests))

Now create the database object as a stub which means just create a database object with parameters but without any functionality because we are only interested to create it at the moment.

现在，将数据库对象创建为存根，这意味着仅创建具有参数但没有任何功能的数据库对象，因为我们目前只想创建它。

Type the following code to create the object:

键入以下代码来创建对象：

-- Creating database object (stored procedure) AddArticle stub (placeholder)
CREATE PROCEDURE AddArticle (@Name VARCHAR(40),@Published_Date DATETIME2)AS
BEGINSET NOCOUNT ON;END
GO

重新运行单元测试以检查对象是否存在 (Rerun the unit test to check object exists)

After creating object stub please rerun the unit test class:

创建对象存根之后，请重新运行单元测试类：

-- Rerun ArticleTest test class
EXEC tsqlt.RunTestClass "ArticleTests"

Your unit test has passed now, so the object which is meant to meet the requirement exists, however, please bear in mind it does not mean that the object necessarily meets the business requirement.

您的单元测试现在已经通过，因此存在符合要求的对象，但是，请记住，这并不意味着该对象必须符合业务要求。

创建单元测试以正确检查对象功能 (Create unit test to check object functions properly)

In test-driven database development unit test is written first to check if object functions properly or not, which in turn triggers the database object to be developed to meet the specification only.

在测试驱动的数据库开发中，首先编写单元测试以检查对象是否正常运行，这又触发要开发的数据库对象仅满足规范。

The recommended way to check AddArticle object functions properly is to write SQL unit test which adds new article to the database by using the potential object and then results are compared with the expected results.

检查AddArticle对象功能正常的推荐方法是编写SQL单元测试，该SQL单元测试通过使用潜在对象将新文章添加到数据库中，然后将结果与预期结果进行比较。

Write the unit test to check object works properly as follows:

编写单元测试以检查对象是否正常运行，如下所示：

--Create unit test to check AddArticle works
CREATE PROCEDURE [ArticleTests].[test to check AddArticle adds article to the table]
AS
-- Assemble
EXEC tSQLt.FakeTable @TableName='dbo.Article',@Identity=1 -- Fake Article table Create TABLE [ArticleTests].[Expected] -- Create expected table
([ArticleId] INT NOT NULL,[Title] VARCHAR(40) NOT NULL,[Published_Date] DATETIME2 NOT NULL)INSERT INTO ArticleTests.Expected -- Insert data into exepcted table
(ArticleId,Title,Published_Date)
VALUES
(1,'Reporting Fundamentals','10 Nov 2018')-- Act
EXEC dbo.AddArticle 'Reporting Fundamentals','10 Nov 2018' -- Run AddArticle procedure which adds new article to the Article table
SELECT * INTO ArticleTests.Actual FROM dbo.Article -- Put the records from Article table into Actual table-- Assert (compare expected table with actual table results)
EXEC tSQLt.AssertEqualsTable @Expected='ArticleTests.Expected',@Actual='ArticleTests.Actual'

运行单元测试以检查对象是否存在并正常工作 (Run unit tests to check object exists and works properly)

Now running all the unit tests should partially pass now because the test to check if object functions properly is going to fail.

现在运行所有单元测试应该部分通过，因为检查对象功能是否正常的测试将失败。

-- Rerun ArticleTest test class
EXEC tsqlt.RunTestClass "ArticleTests"

重构对象并重新运行单元测试 (Refactor object and rerun unit tests )

Modify AddArticle stored procedure with correct insert statement such that all the unit tests pass now.

使用正确的insert语句修改AddArticle存储过程，以使所有单元测试现在都通过。

-- Alter database object (stored procedure) AddArticle to properly add new article
ALTER PROCEDURE AddArticle(@Title VARCHAR(40),@Published_Date DATETIME2)AS
BEGINSET NOCOUNT ON;INSERT INTO dbo.Article (Title, Published_Date)VALUES(@Title,@Published_Date)END
GO

Run the unit tests:

运行单元测试：

 -- Run unit tests related to ArticleTests
EXEC tsqlt.RunTestClass "ArticleTests"

Congratulations, the fact that all the unit tests have passed now ensures that the object is capable of meeting the business requirement to add new article to the database now.

祝贺您，现在所有单元测试都已通过，这确保了该对象能够满足将新文章添加到数据库中的业务需求。

摘要 (Summary)

After going through this article and following the walkthrough you have familiarised yourself with test-driven database development methodology which is not only feature-rich, but to the point and also offers a lot of flexibility in handling business requirements ranging from simple to complex scenarios.

在阅读完本文并完成演练之后，您已经熟悉了测试驱动的数据库开发方法，该方法不仅功能丰富，而且直指重点，并且在处理从简单到复杂场景的业务需求方面提供了很大的灵活性。

目录 (Table of contents)

tSQLt – A Forgotten Treasure in Database Unit Testing

Conventional SQL Unit Testing with tSQLt in Simple Words

Fundamentals of Test-Driven Database Development (TDDD) with tSQLt unit testing

10 Most Common SQL Unit Testing Mistakes

Why you should cleverly name Database Objects for SQL Unit Testing

Three Standard SQL Unit Tests you can write against any Stored Procedure

Creating SQL Unit Testing Utility Procedures with tSQLt

tSQLt –数据库单元测试中被遗忘的宝藏

简单单词中使用tSQLt进行的常规SQL单元测试

tSQLt单元测试的测试驱动数据库开发（TDDD）基础

10个最常见SQL单元测试错误

为什么要为SQL单元测试巧妙地命名数据库对象

您可以针对任何存储过程编写三个标准SQL单元测试

使用tSQLt创建SQL单元测试实用程序过程

翻译自: https://www.sqlshack.com/fundamentals-of-test-driven-database-development-tddd-with-tsqlt-unit-testing/