Continuous Integration for SQL Server Part II – Integration Testing

Update 31st March 2015

Since writing this article, a number of Redgate product development changes have taken place. Some of the references in the article are now out of date, so here’s a summary of the changes that have taken place:

  1. Redgate now offers an easier way to run continuous integration testing, using SQL CI as part of DLM Automation. If you have tSQLt unit tests, SQL CI runs them for you, checking your changes before they reach your test environment.
  2. DLM Automation also includes a plugin for TeamCity and TFS to make it even easier to set up continuous integration for your databases if you are using either of these build servers.
  3. SQL Test is part of the SQL Toolbelt and enables you to write database unit tests in T-SQL and then run them in SSMS.

If you have any questions about automating the deployment of Database Projects using the latest versions of our database lifecycle management tools, please contact the DLM team for more information or an online demo:

Original article

My previous post, on setting up Continuous Integration for SQL Server databases using GitHub, Bamboo and Red Gate’s tools, covered the first two parts of a simple Database Continuous Delivery process:

  1. Putting your database in to a source control system, and,
  2. Running a continuous integration process, each time changes are checked in.

However there is, of course, a lot more to to Continuous Delivery than that. Specifically, in addition to the above:

  1. Putting some actual integration tests in to the CI process (otherwise, they don’t really do much, do they!?),
  2. Deploying the database changes with a managed, automated approach,
  3. Monitoring what you’ve just put live, to make sure you haven’t broken anything.

This post will detail how to set up a very simple pipeline for implementing the first of these (continuous integration testing). NB: A lot of the setup in this post is built on top of the configuration from before, so it might be difficult to implement this post without running through part I first.

There’ll then be a third post on automated database deployment followed by a final post dealing with the last item – monitoring changes on the live system.

In the previous post, I used a mixture of Red Gate products and other 3rd party software – GitHub and Atlassian Bamboo specifically. This was partly because I believe most people work in an heterogeneous environment, using software from different vendors to suit their purposes and I wanted to show how this could work for this process. For example, you could easily substitute Atlassian’s BitBucket or Stash for GitHub, depending on your needs, or use an alternative CI server such as TeamCity, TFS or Jenkins.

However, in this, post, I’ll be mostly using Red Gate products only (other than tSQLt). I would do this, firstly because I work for Red Gate. However, I also think that in the area of Database Delivery processes, nobody else has the offerings to implement this process fully – so I didn’t have any choice!

Background on Continuous Delivery

For me, a great source of information on what makes a proper Continuous Delivery process is the Jez Humble and David Farley classic:

Continuous Delivery – Reliable Software Releases through Build, Test, and Deployment Automation

This book is not of course, primarily about databases, and the process I outline here and in the previous article is a gross simplification of what Jez and David describe (not least because it’s that much harder for databases!). However, a lot of the principles that they describe can be equally applied to database development and, I would argue, should be.

As I say however, what I describe here is a very simple version of what would be required for a full production process. A couple of useful resources on handling some of these complexities can be found in the following two references:

Refactoring Databases – Evolutionary Database Design, by Scott J Ambler and Pramod J. Sadalage

Versioning Databases – Branching and Merging, by Scott Allen

In particular, I don’t deal at all with the issues of multiple branches and merging of those branches, an issue made particularly acute by the use of GitHub.

The other point worth making is that, in the words of Martin Fowler:

Continuous Delivery is about keeping your application in a state where it is always able to deploy into production.    

I.e. we are  not talking about continuously delivery updates to the production database every time someone checks in an amendment to a stored procedure. That is possible (and what Martin calls  Continuous Deployment). However, again, that’s more than I describe in this article. And I doubt I need to remind DBAs or Developers to  Proceed with Caution!

Integration Testing

Back to something practical. The next stage, building on our set up from the previous article, is to add in some integration tests to the process. As I say, the CI process, though interesting, isn’t enormously useful without some sort of test process running.

For this we’ll use the tSQLt framework, an open source framework designed specifically for running SQL Server tests.  tSQLt  is part of Red Gate’s SQL Test found on  or can be downloaded  separately from  – though I’ll provide a step-by-step guide below for setting this up.

Getting tSQLt set up via SQL Test

  1. Click on the link  and click on the blue Download button to download the Red Gate SQL Test product, if not already installed. 1-SQL-Test-download.png
  2. Follow the install process for SQL Test to install the SQL Server Management Studio (SSMS) plugin on to your machine, if not already installed.
  3. Open SSMS. You should now see SQL Test under the Tools menu:


  4. Clicking this link will give you the basic SQL Test dialogue:


  5. As yet, though we’ve installed the SQL Test product we  haven’t yet installed the tSQLt test framework on to any particular database. To do this, we need to add our RedGateApp database using this dialogue, by clicking on the + Add Database to SQL Test…  link, selecting the RedGateApp database and clicking the Add Database link:


  6. In the next screen, SQL Test describes what will be installed on the database for the tSQLt framework. Also in this dialogue, uncheck the “Add SQL Cop tests” option (shown below). SQL Cop  is a great set of pre-defined tests that work within the tSQLt framework to check the general health of your SQL Server database. However, we won’t be using them in this particular simple example:


  7. Once you’ve clicked on the OK button, the changes described in the dialogue will be made to your database. Some of these are shown in the left-hand-side below:


  8. We’ve now installed the framework. However, we haven’t actually created any tests, so this will be the next step. But, before we proceed, we’ve made an update to our database so should, again check this in to source control, adding comments as required:




  9. Also worth a quick check that your build still runs with the new additions!:


    (And a quick check of the RedGateAppCI database shows that the changes have been made).

Creating and Testing a Unit Test

There are, of course, a lot of very interesting unit tests that you could and should set up for a database. The great thing about the tSQLt framework is that you can write these in SQL. The example I’m going to use here is pretty Mickey Mouse – our database table is going to include some email addresses as reference data and I want to check whether these are all in a correct email format. Nothing clever but it illustrates the process and hopefully shows the method by which more interesting tests could be set up.

Adding Reference Data to our Database

  1. To start, I want to add some reference data to my database, and have this source controlled (as well as the schema). First of all I need to add some data in to my solitary table – this can be done a number of ways, but I’ll do this in SSMS for simplicity:


  2. I then add some reference data to my table:


  3. Currently this reference data just exists in the database. For proper integration testing, this needs to form part of the  source-controlled version of the database – and so needs to be added to the Git repository. This can be done via SQL Source Control, though first a Primary Key needs to be added to the table. Right click the table, select Design, then right-click on the first “id” row. Then click on “Set Primary Key”:


    NB: once this change is made, click Save to save the change to the table.

  4. Then, to source control this reference data, right click on the table (dbo.Email) and selecting the following option:


  5. In the next screen, link the data in the Email table, by selecting it from the list and clicking “save and close”:


  6. We should at this point re-commit the changes (both the addition of the Primary Key, and the data) to the Git repo. NB: From here on, I won’t show screenshots for the GitHub side of things – it’s the same each time: whenever a change is made in SQL Source Control and committed to your local folder, you then need to sync this in the GitHub Windows client (as this is where the build server, Bamboo is taking it from). An interesting point to note here, when these changes are committed in SQL Source Control (right-click database and select “Commit Changes to Source Control..”):


    The display gives a warning about possibly needing a migration script for the “Add Primary Key” step of the changes. This isn’t actually necessary in this case, but this mechanism would allow you to create override scripts to replace the default change scripts created by the SQL Compare engine (which runs underneath SQL Source Control). Ignoring this message (!), we add a comment and commit the changes to Git. I then sync these, run a build (or the build gets run automatically), and check that the data is being deployed over to the target RedGateAppCI database:


Creating and Running the Test

As I mention, the test I’m going to use here is a very simple one –  are the email addresses in my reference table valid?  This isn’t of course, a full test of email validation (I expect the email addresses I’ve chosen here aren’t really the those of the Fab Four) – but just a very basic check of format used. I’ve taken the relevant SQL from this Stack Overflow article.

  1. In SSMS select “SQL Test” from the Tools menu, then click on + New Test:


  2. In the next screen, give your new test a name, and also enter a name in the Test Class box (test classes are schemas that help you keep things organised). Also check that the database in which the test is going to be created is correct – RedGateApp in this example:


  3. Click “Create Test”. After closing a couple of subsequent dialogues, you’ll see a dummy script for the test, that needs filling in:


  4. We now need to define the SQL for our test. As mentioned before, tSQLt allows you to write your unit tests in T-SQL, and the code I’m going to use here is as below. This needs to be copied and pasted in to the query window, to replace the default given by tSQLt:
  5. Once this script is entered, hit execute to add the Stored Procedure to the database.
  6. Before committing the test to source control,  it’s worth just checking that it works! For a positive test, click on “SQL Test” from the Tools menu, then click Run Tests. You should see output like the following:


    – a green tick to indicate success!

  7. But of course, what we also need to do is test that this is actually doing something by showing a failed test. Edit one of the email addresses in your table to an incorrect format:


  8. Now, re-run the same SQL Test as before and you’ll see the following:


    Great – we now know that our test is really doing something! You’ll also see a useful error message at the bottom of SSMS:


    (leave the email address as invalid for now, for the next steps).

  9. The next stage is to check this new test in to source control again, by right-clicking on the database and checking in the changes with a commit message (and not forgetting to sync in the GitHub client):


Checking that the Tests are Running as Integration Tests

After the changes above are made, and after a build has run on Bamboo (manual or automatic), looking at the Stored Procedures for the RedGateAppCI, the SPROC for the new test has been moved over to the database. However this is not exactly what we were after. We didn’t want to just copy objects from one database to another, but actually run the tests as part of the build/integration test process. I.e. we’re continuously checking any changes we make (in this case, to the reference data emails), to ensure we’re not breaking a test that we’ve set up.

  1. The behaviour we want to see is that, if we check in static data that is incorrect (as we did in step 9 above) and we have the tSQLt test set up, then our build in Bamboo should fail. However, re-running the build shows the following:


    – sadly, a successful build!

  2. To make sure the tSQLt tests are run as part of the integration test, we need to amend a switch in the Red Gate CI config file. First, navigate to file sqlCI.targets in your working folder:


  3. Edit this document, make the following change, save the document, then commit and sync this change in the GitHub client:
  4. Now, if we re-run the build in Bamboo (NB: I’ve moved to a new server here, hence different address and build number):Bamboo-Failed-Build.png

    – superb, a broken build!

  5. The error message isn’t great here, so to get more detailed info, click on the full build log link on this page (below the fold). The interesting part of the log shown is towards the bottom. Pulling out this part:

  6. As a final check, we should make sure that, if we now fix this error, the build succeeds. So in SSMS, I’m going to correct the invalid email address, then check this change in to SQL Source Control (with a comment), commit to GitHub, and re-run the build:





  7. This should have fixed the build:


    It worked!


This has been a very quick run through the implementation of CI for databases, including tSQLt tests to test whether your database updates are working.

The next post in this series will focus on automated deployment – we’ve tested our database changes, how can we now deploy these to target sites?