Unit testing 实体框架集成测试DropCreateDatabase始终不在测试之间清除数据库

我正在编写一组集成测试（使用MS Test进行单元测试，测试Entity Framework 4.2是否将所有类正确地持久化到数据库）

当我一个接一个地运行所有测试时，它们都工作得很好。当我在一个组中运行它们时——其中一些由于返回的对象数量错误而失败——看起来db在测试开始时被清理了一次，而不是在每个测试之间——尽管我可以看到创建了一个新的上下文，然后为每个测试处理了它

有什么想法吗

public class EmptyDataInitializer : DropCreateDatabaseAlways<myContext>
{
    protected override void Seed(myContext db)
    {
        //Do Nothing Create Empty Database
        db.SaveChanges();
        base.Seed(db);
    }
}

公共类EmptyDataInitializer:DropCreateDatabaseAlways
{
受保护的覆盖无效种子（myContext db）
{
//不执行任何操作创建空数据库
db.SaveChanges（）；
基部种子（db）；
}
}

单元/集成测试的精简版本

[TestClass]
public class PersistanceTests
{
    //Creating two instances of our Repository so that we can make sure that we are reading from our database rather than in-memory
    private myContext _db;
    private myContext _dbResults;
    private readonly ISettings _configSettings;

    public PersistanceTests()
    {
        _configSettings = MockRepository.GenerateStub<ISettings>();
        _configSettings.ConnectionString = "data source=.;initial catalog=myContext_Test; Integrated Security=SSPI; Pooling=false";

        Database.SetInitializer(new EmptyDataInitializer());
    }

    //This is called a single time after the last test has finished executing
    [TestCleanup]
    public void TearDownTest()
    {
       _db.Dispose();
        _db = null;
       _dbResults.Dispose();
        _dbResults = null;
    }

    //This is called each time prior to a test being run

    [TestInitialize]
    public void SetupTest()
    {          
        _db = new myContext(_configSettings);
        _dbResults = new myContext(_configSettings);

        // This forces the database to initialise at this point with the initialization data / Empty DB
        var count = _db.Accounts.Count();
        var resultCount = _dbResults.Accounts.Count();
        if (count != resultCount) throw new InvalidOperationException("We do not have a consistant DB experiance.");
    }
    [TestMethod]
    public void OrganisationPersistanceTest()
    {
        // Arrange
        var apple = new Organisation { Name = "Apple" };
        _db.Organisations.Add(apple);
        // Act
        _db.SaveChanges();
        var organisationsCount = _dbResults.Organisations.Count();
        var organisationsAppleCount = _dbResults.Organisations.Where(a => a.Id == apple.Id).Count();
        var result = _dbResults.Organisations.FirstOrDefault(a => a.Id == apple.Id);
        // Assert
        Assert.IsTrue(organisationsCount == 1, string.Format("Organisations Count Mismatch -  Actual={0}, Expected={1}", organisationsCount, 1));
        Assert.IsTrue(organisationsAppleCount == 1, string.Format("Apple Organisations Count Mismatch -  Actual={0}, Expected={1}", organisationsAppleCount, 1));
        Assert.IsNotNull(result, "Organisations Result should not be null");
        Assert.AreEqual(result.Name, apple.Name, "Name Mismatch");
    }

    //A Unit test
    [TestMethod]
    public void OrganisationWithNumberOfPeople_PersistanceTest()
    {
        // Arrange
        var person = new Person { Firstname = "Bea" };
        var anotherPerson = new Person { Firstname = "Tapiwa" };
        var apple = new Organisation { Name = "Apple" };
        apple.AddPerson(person);
        apple.AddPerson(anotherPerson);
        _db.Organisations.Add(apple);
        // Act
        _db.SaveChanges();
        var organisationsCount = _dbResults.Organisations.Count();
        var organisationsAppleCount = _dbResults.Organisations.Where(a => a.Id == apple.Id).Count();
        var result = _dbResults.Organisations.FirstOrDefault(a => a.Id == apple.Id);
        var peopleCountInOrganisation = result.People.Count();
        // Assert
        Assert.IsTrue(organisationsCount == 1, string.Format("Organisations Count Mismatch -  Actual={0}, Expected={1}", organisationsCount, 1));
        Assert.IsTrue(organisationsAppleCount == 1, string.Format("Apple Organisations Count Mismatch -  Actual={0}, Expected={1}", organisationsAppleCount, 1));
        Assert.IsNotNull(result, "Organisations Result should not be null");
        Assert.AreEqual(result.People.Count, peopleCountInOrganisation, "People count mismatch in organisation Apple - Actual={0}, Expected={1}", peopleCountInOrganisation, 2); 
        Assert.AreEqual(result.Name, apple.Name, "Name Mismatch");
   }

[TestClass]
公共类持久性测试
{
//创建存储库的两个实例，以便确保从数据库而不是内存中读取
私有myContext数据库；
私有myContext_dbResults；
专用只读设置\u配置设置；
公共持久性测试（）
{
_configSettings=MockRepository.GenerateSub（）；
_configSettings.ConnectionString=“数据源=；初始目录=myContext\u测试；集成安全性=SSPI；池=false”；
SetInitializer（新的EmptyDataInitializer（））；
}
//这在最后一个测试完成执行后称为一次
[测试清理]
公共无效删除测试（）
{
_db.Dispose（）；
_db=null；
_dbResults.Dispose（）；
_dbResults=null；
}
//每次运行测试之前都会调用此函数
[测试初始化]
公共测试（）
{          
_db=新的myContext（_configSettings）；
_dbResults=新的myContext（_configSettings）；
//这将强制数据库在此时使用初始化数据/空数据库进行初始化
var count=_db.Accounts.count（）；
var resultCount=_dbResults.Accounts.Count（）；
如果（count！=resultCount）抛出新的InvalidOperationException（“我们没有一致的数据库经验”）；
}
[测试方法]
公共无效组织持久性测试（）
{
//安排
var apple=新组织{Name=“apple”}；
_db.organizations.Add（苹果）；
//表演
_db.SaveChanges（）；
var organizationScont=_dbResults.organizations.Count（）；
var organizationsaplecount=_dbResults.organizations.Where（a=>a.Id==apple.Id）.Count（）；
var result=\u dbResults.organizations.FirstOrDefault（a=>a.Id==apple.Id）；
//断言
Assert.IsTrue（OrganizationScont==1，string.Format（“Organizations Count Mismatch-Actual={0}，Expected={1}”，OrganizationScont，1））；
Assert.IsTrue（organizationsapplecount==1，string.Format（“苹果组织计数不匹配-实际={0}，预期={1}”，organizationsapplecount，1））；
Assert.IsNotNull（结果，“结果不应为null”）；
Assert.AreEqual（result.Name，apple.Name，“名称不匹配”）；
}
//单元测试
[测试方法]
具有人数的公共无效组织\u持久性测试（）
{
//安排
var person=newperson{Firstname=“Bea”}；
var anotherPerson=新人{Firstname=“Tapiwa”}；
var apple=新组织{Name=“apple”}；
苹果。AddPerson（人）；
apple.AddPerson（另一个人）；
_db.organizations.Add（苹果）；
//表演
_db.SaveChanges（）；
var organizationScont=_dbResults.organizations.Count（）；
var organizationsaplecount=_dbResults.organizations.Where（a=>a.Id==apple.Id）.Count（）；
var result=\u dbResults.organizations.FirstOrDefault（a=>a.Id==apple.Id）；
var peopleCountInOrganization=result.People.Count（）；
//断言
Assert.IsTrue（OrganizationScont==1，string.Format（“Organizations Count Mismatch-Actual={0}，Expected={1}”，OrganizationScont，1））；
Assert.IsTrue（organizationsapplecount==1，string.Format（“苹果组织计数不匹配-实际={0}，预期={1}”，organizationsapplecount，1））；
Assert.IsNotNull（结果，“结果不应为null”）；
Assert.AreEqual（result.People.Count，PeopleCountInOrganization，“组织中的人员计数不匹配-实际={0}，预期={1}”，PeopleCountInOrganization，2）；
Assert.AreEqual（result.Name，apple.Name，“名称不匹配”）；
}

}

---

在测试过程中，我可以看到SetupTest和TearDownTest方法被调用，但在测试之间，它似乎没有清理数据库

好的，更好的答案-添加一个数据库。初始化（force:true）； 进入测试初始化方法

[TestInitialize]
public void SetupTest()
{          
    _db = new myContext(_configSettings);
    _db.Database.Initialize(force: true);
    _dbResults = new myContext(_configSettings);

    // This forces the database to initialise at this point with the initialization data / Empty DB
    var count = _db.Accounts.Count();
    var resultCount = _dbResults.Accounts.Count();
    if (count != resultCount) throw new InvalidOperationException("We do not have a consistant DB experiance.");
}

---

我使用助手来完成此类任务：

public abstract class TestingHelper
{
        public static void ClearDatabase()
        {
            DatabaseContext myDbContext = new DatabaseContext();
            myDbContext.Database.Delete();
            myDbContext.Database.Create();
            //FillDatabase(lawyers); //<- OPTIONAL if you want to add rows to any type tables
        }
}

---

好的，答案似乎是修改TestCleanup方法，以便在每次测试[TestCleanup]public void TearDownTest（）{if（_db.database.Exists（））{{u db.database.Delete（）之后显式删除并重新创建数据库db.Database.CreateIfNotExists（）；}db.Dispose（）；db=null；dbResults.Dispose（）；dbResults=null；}好的更好答案-添加一个数据库。初始化（强制：true）；进入测试初始化方法。[TestInitialize]public void SetupTest（）{_db=new myContext（_configSettings）；_db.Database.Initialize（force:true）；这适用于常规连接（非MDF），在调用

.Initia之后，是否有提示，说明当连接字符串包含
AttachDBFilename
参数时，为什么相同的代码不起作用
[SetUp]
public void MyTests_SetUp()
{
      TestingHelper.ClearDatabase();
}