[Persistent]
public class Person
{
  private string firstName;
  private string lastName;
 
  public string FirstName
  {
    get
    {
      return firstName;
    }
    set
    {
      firstName = value;
    }
  }
 
  public string LastName
  {
    get
    {
      return lastName;
    }
    set
    {
      lastName = value;
    }
  }
 
  public string FullName
  {
    get
    {
      return this.firstName + " " + this.lastName;
    }
  }
}

public class PersonService
{
  private readonly IObjectScope scope;
 
  public PersonService() : this( ObjectScopeProvider1.ObjectScope() ) { }
 
  public PersonService( IObjectScope scope )
  {
    this.scope = scope;
  }
 
  public void AddPerson( Person person )
  {
    if ( Blacklist.Contains( person.LastName ) )
    {
      return;
    }
 
    scope.Transaction.Begin();
 
    scope.Add( person );
 
    scope.Transaction.Commit();
  }
 
  public List<String> Blacklist = new List<String>();
}

[TestFixture]
public class PersonServiceTestsWithoutMocking
{
  private IObjectScope scope;
 
  [SetUp]
  public void TestSetup()
  {
    scope = ObjectScopeProvider1.GetNewObjectScope();
    scope.Transaction.Begin();
  }
 
  [TearDown]
  public void TearDown()
  {
    if ( scope.Transaction.IsActive )
    {
      scope.Transaction.Rollback();
    }
    scope.Dispose();
  }
 
  [Test]
  public void PersonShouldNotBeAddedIfBlacklisted()
  {
    // Set up PersonService
    PersonService ps = new PersonService();
    ps.Blacklist.Add( "Sparrow" );
 
    // Jack Sparrow shouldn't be added to the database
    Person jack = new Person { FirstName = "Jack", LastName = "Sparrow" };
    ps.AddPerson( jack );
 
    Person sparrow = scope.Extent().SingleOrDefault( p => p.LastName.Equals( "Sparrow" ) );
    Assert.IsNull( sparrow );
  }
 
  [Test]
  public void PersonShouldBeAddedIfNotBlacklisted()
  {
    // Set up PersonService
    PersonService ps = new PersonService();
    ps.Blacklist.Add( "Sparrow" );
 
    // John Smith should be added to the database
    Person john = new Person { FirstName = "John", LastName = "Smith" };
    ps.AddPerson( john );
 
    Person smith = scope.Extent().SingleOrDefault( p => p.LastName.Equals( "Smith" ) );
    Assert.IsNotNull( smith );
  }
}

[TestFixture]
public class PersonServiceTestsUsingMocking
{
  [Test]
  public void PersonShouldNotBeAddedIfBlacklisted()
  {
    // Create our mock ObjectScope
    IObjectScope mockScope = MockRepository.GenerateMock();
 
    // Set up PersonService using the mock ObjectScope
    PersonService ps = new PersonService( mockScope );
    ps.Blacklist.Add( "Sparrow" );
 
    // Jack Sparrow shouldn't be added to the database
    Person jack = new Person { FirstName = "Jack", LastName = "Sparrow" };
    ps.AddPerson( jack );
 
    // As Jack is blacklisted, we assert that IObjectScope.Add wasn't called
    mockScope.AssertWasNotCalled( s => s.Add( jack ) );
  }
 
  [Test]
  public void PersonShouldBeAddedIfNotBlacklisted()
  {
    // Create our mock ObjectScope
    IObjectScope mockScope = MockRepository.GenerateMock();
    // Create our mock Transaction (we need this because of the calls to Transaction.Begin() and Transaction.Commit())
    ITransaction mockTransaction = MockRepository.GenerateMock();
 
    // We set the expectation that IObjectScope.Transaction will be called twice, for Begin() and Commit()
    mockScope.Expect( s => s.Transaction ).Return( mockTransaction ).Repeat.Twice();
 
    // Set up PersonService using the mock ObjectScope
    PersonService ps = new PersonService( mockScope );
    ps.Blacklist.Add( "Sparrow" );
 
    // John Smith should be added to the database
    Person john = new Person { FirstName = "John", LastName = "Smith" };
    ps.AddPerson( john );
 
    // As John isn't blacklisted, IObjectScope.Add should have been called
    mockScope.AssertWasCalled( s => s.Add( john ) );
 
    mockScope.VerifyAllExpectations();
  }
}