The TestFu.Data namespace contains a Random DataRow generator to help developer test databases, data layers, business layers, etc...

Classes

	Class	Description
	DbAdministratorBase	Abstract class to perform administrative tasks on a database
	DbFactoryBase
	DbFixture	An abstract base class for test fixtures involving database testing.
	DbGenerator

Interfaces

	Interface	Description
	ICheckValidator	A validator check checks constraints
	IDatabasePopulator	A database populator instance.
	IDataGenerator	An random data generator.
	IDataGeneratorCollection	A collection of IDataGenerator.
	IDbFactory	A factory for IDbConnection and IDbCommand instances.
	IForeignKeyProvider	An instance that can fill a DataRow with data that are compatible with a given ForeignKeyConstraint.
	IForeignKeyProviderCollection	A collection of IForeignKeyProvider.
	IRangeDataGenerator
	ITablePopulator	An random DataRow generator compatible with the schema of a given DataTable.
	ITablePopulatorCollection	A collection of ITablePopulator.
	IUniqueValidator	A validator for UniqueConstraint constraints.
	IUniqueValidatorCollection	A collection of IUniqueValidator.

Enumerations

	Enumeration	Description
	DbBackupDevice	Enumeration of available SQL backup devices

Examples

This example shows some usage of the DbAdministratorBase class. This class can be used to easily backup, restore, create or drop databases on a server. SqlAdministrator is the implementation for the MSSQL server:

CopyC#

[C#]
using System;
using TestFu.Data;

public class Demo
{
    public static void Main(string[] args)
    {
        DbAdministrator admin = new SqlAdministrator("...");    

        // backup Northwind
        admin.Backup("Northwind",SqlBackupDevice.Disk,@"c:\Backups\Northwind.bkp");

        // drop Northwind
        admin.Drop("Northwind");

        // restore Northwind
        admin.Restore("Northwind",SqlBackupDevice.Disk,@"c:\Backups\Northwind.bkp");
    }
}

Examples

The DbFixture (SqlFixture for MsSQL server) can be used as a base class for the fixtures involving database testing.

CopyC#

[TestFixture]
public class DatabaseTest : SqlFixture
{
    public DatabaseTest()
    :base("Data Source=testserver;...","MyTestDatabase")
    {}

    [SetUp]
    public void SetUp()
    {
        this.Open();
        this.BeginTransaction();
    }

    [Test]
    public void Selec()
    {
        IDbCollection cmd = this.Connection.CreateCommand("select * from anytable",this.Transaction);
        ...
    }

    [TearDown]
    public void TearDown()
    {
        this.Close();
    }
}

Examples

This example shows how the data generator can be used to create unit tests on database. In this example, we setup the dummy DataSetUserOrderProductDatabase and the populator in the SetUp method.

CopyC#

using System;
using System.Data;
using MbUnit.Core.Framework;
using MbUnit.Framework;
using TestFu.Data;
using TestFu.Data.Populators;

namespace TestFu.Tests.Data
{
    [TestFixture]
    public class DatabasePopulatorTest
    {
        private UserOrderProductDatabase db;
        private DatabasePopulator pop;
        private ITablePopulator users;
        private ITablePopulator orders;
        private ITablePopulator products;
        private ITablePopulator orderProducts;

        [SetUp]
        public void SetUp()
        {
            this.db=new UserOrderProductDatabase();
            this.pop = new DatabasePopulator();
            this.pop.Populate(this.db.DataSet);

            this.users=this.pop.Tables[this.db.Users];
            this.orders=this.pop.Tables[this.db.Orders];
            this.products=this.pop.Tables[this.db.Products];
            this.orderProducts=this.pop.Tables[this.db.OrderProducts];
        }

        [Test]
        public void AddOneUser()
        {
            DataRow row = users.Generate();
            this.db.Users.Rows.Add(row);
        }

        [Test]
        public void AddOneUserOneOrder()
        {
            this.AddOneUser();
            DataRow row = orders.Generate();
            this.db.Orders.Rows.Add(row);
        }

        [Test]
        [ExpectedException(typeof(InvalidOperationException))]
        public void AddOneOrder()
        {
            DataRow row = orders.Generate();
        }

        [Test]
        [ExpectedException(typeof(InvalidOperationException))]
        public void AddOneOrderProduct()
        {
            DataRow row = orderProducts.Generate();
        }

        [Test]
        public void AddOneUserOneOrderOneProduct()
        {
            this.AddOneUserOneOrder();

            DataRow row = products.Generate();
            this.db.Products.Rows.Add(row);
        }

        [Test]
        public void AddOneUserOneOrderOneProductOneProductOrder()
        {
            this.AddOneUserOneOrderOneProduct();
            DataRow row=orderProducts.Generate();
            this.db.OrderProducts.Rows.Add(row);
        }

        [Test]
        public void AddTwoUsers()
        {
            AddOneUser();
            AddOneUser();
        }

        [TearDown]
        public void Check()
        {
            this.db.AcceptChanges();
            Console.WriteLine(db.ToString());
        }
    }
}

Examples

The following codes decribes a simple User - Order - Product database contains 4 tables: Users, Orders, Products and OrderProducts.

CopyC#

using System;
using System.Data;
using System.IO;
using System.Xml;

namespace TestFu.Tests.Data
{
    public class UserOrderProductDatabase
    {
        private DataSet dataSet;
        private DataTable users;
        private DataColumn userID;
        private DataColumn userName;

        private DataTable orders;
        private DataColumn orderID;
        private DataColumn orderDate;
        private DataColumn oUserID;

        private DataTable products;
        private DataColumn productID;
        private DataColumn productName;
        private DataColumn productPrice;

        private DataTable orderProducts;
        private DataColumn opOrderID;
        private DataColumn opProductID;
        private DataColumn quantity;

        public UserOrderProductDatabase()
        {
            this.dataSet=new DataSet();

            this.users=this.dataSet.Tables.Add("Users");
            this.userID = this.users.Columns.Add("UserID",typeof(int));
            this.userName=this.Users.Columns.Add("UserName",typeof(string));
            this.userName.AllowDBNull=false;

            this.orders=this.dataSet.Tables.Add("Orders");
            this.orderID=this.orders.Columns.Add("OrderID",typeof(int));
            this.orderDate = this.orders.Columns.Add("OrderDate",typeof(DateTime));
            this.oUserID = this.orders.Columns.Add("UserID",typeof(int));

            this.products=this.dataSet.Tables.Add("Products");
            this.productID=this.products.Columns.Add("ProductID",typeof(int));
            this.productName = this.products.Columns.Add("ProductName",typeof(string));
            this.productPrice = this.products.Columns.Add("ProductPrice",typeof(decimal));

            this.orderProducts=this.dataSet.Tables.Add("OrderProducts");
            this.opOrderID=this.orderProducts.Columns.Add("OrderID",typeof(int));
            this.opProductID=this.orderProducts.Columns.Add("ProductID",typeof(int));
            this.quantity=this.orderProducts.Columns.Add("Quantity",typeof(int));

            // pks
            users.Constraints.Add("PK_Users",userID,true);
            orders.Constraints.Add("PK_Orders",orderID,true);
            products.Constraints.Add("PK_Products",productID,true);
            orderProducts.Constraints.Add("PK_OrderProducts",
                new DataColumn[]{ opOrderID, opProductID}
                ,true);

            // fks
            orders.Constraints.Add("FK_Orders_Users",userID,oUserID);
            orderProducts.Constraints.Add("FK_OrderProducts_Orders",orderID,opOrderID);
            orderProducts.Constraints.Add("FK_OrderProducts_Products",productID,opProductID);
        }
    }
}