public void WithSetup_sets_setup_to_null_when_passing_null(PersistenceTestBuilder sut,
[NoRecursion] SampleEntity entity)
{
var result = (PersistenceTestBuilder <SampleEntity>)AsSetupChooser(sut)
.WithSetup(null)
.WithEntity(entity);
Assert.That(result?.Setup, Is.Null);
}
/// <summary>
/// Specifies an optional 'setup' (aka 'pre-test') action which should be executed before the entity
/// is saved. This allows for saving of dependency/parent entities or other relevant database setup
/// which must be performed before the entity is saved.
/// </summary>
/// <returns>A service with which to choose the entity to be saved.</returns>
/// <param name="builder">The persistence test builder.</param>
/// <param name="setup">The setup action.</param>
/// <param name="implicitTransaction">If set to <c>true</c> then the setup action will be executed within an implicit database transaction.</param>
public static IChoosesEntity WithSetup(this PersistenceTestBuilder builder,
Action <INhSession> setup,
bool implicitTransaction = true)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var setupAction = GetSetupAction(setup);
return(((IConfiguresTestSetup)builder).WithSetup(setupAction, implicitTransaction));
}
public void WithSetup_sets_setup_to_action_when_provided([Frozen] IGetsSession sessionProvider,
PersistenceTestBuilder sut,
[NoRecursion] SampleEntity entity,
[Frozen] ISession session,
[Frozen] ITransaction tran)
{
bool executed = false;
var action = GetSetup(getter => { executed = true; });
var result = (PersistenceTestBuilder <SampleEntity>)AsSetupChooser(sut)
.WithSetup(action)
.WithEntity(entity);
result.Setup(sessionProvider);
Assert.That(executed, Is.True);
}
public void WithSetup_does_not_use_transaction_when_specified_not_to([Frozen] IGetsSession sessionProvider,
PersistenceTestBuilder sut,
[NoRecursion] SampleEntity entity,
ISession session,
ITransaction tran)
{
Mock.Get(sessionProvider).Setup(x => x.GetSession()).Returns(session);
Mock.Get(session).Setup(x => x.BeginTransaction()).Returns(tran);
var action = GetSetup(getter => { /* Noop */ });
var result = (PersistenceTestBuilder <SampleEntity>)AsSetupChooser(sut)
.WithSetup(action, false)
.WithEntity(entity);
result.Setup(sessionProvider);
Mock.Get(session).Verify(x => x.BeginTransaction(), Times.Never);
}
public void WithEqualityRule_uses_rule_in_spec(IGetsEqualityResult <SampleEntity> equalityRule,
IGetsSession sessionProvider,
[NoRecursion] SampleEntity entity,
ITestsPersistence <SampleEntity> tester)
{
Mock.Get(tester).Setup(x => x.GetTestResult()).Returns(() => null);
PersistenceTestSpec <SampleEntity> specification = null;
var builder = new PersistenceTestBuilder <SampleEntity>(sessionProvider, entity, null, spec =>
{
specification = spec;
return(tester);
});
var sut = AsComparerChooser(builder);
sut.WithEqualityRule(equalityRule);
Assert.That(specification?.EqualityRule, Is.SameAs(equalityRule));
}
public void WithEqualityRule_can_configure_a_rule(IEqualityComparer <string> comparer,
IGetsSession sessionProvider,
[NoRecursion] SampleEntity entity,
ITestsPersistence <SampleEntity> tester)
{
Mock.Get(tester).Setup(x => x.GetTestResult()).Returns(() => null);
PersistenceTestSpec <SampleEntity> specification = null;
var builder = new PersistenceTestBuilder <SampleEntity>(sessionProvider, entity, null, spec =>
{
specification = spec;
return(tester);
});
var sut = AsComparerChooser(builder);
sut.WithEqualityRule(b => b.ForProperty(x => x.StringProperty, c => c.UsingComparer(comparer)));
specification?.EqualityRule?.GetEqualityResult(entity, entity);
Mock.Get(comparer)
.Verify(x => x.Equals(entity.StringProperty, entity.StringProperty), Times.Once);
}
public void WithEqualityComparer_uses_comparer_in_spec(IEqualityComparer <SampleEntity> comparer,
IGetsSession sessionProvider,
[NoRecursion] SampleEntity entity,
ITestsPersistence <SampleEntity> tester)
{
Mock.Get(tester).Setup(x => x.GetTestResult()).Returns(() => null);
PersistenceTestSpec <SampleEntity> specification = null;
var builder = new PersistenceTestBuilder <SampleEntity>(sessionProvider, entity, null, spec =>
{
specification = spec;
return(tester);
});
var sut = AsComparerChooser(builder);
// Select the comparer and then execute the rule from the spec
// so that the comparer should be executed with it
sut.WithEqualityComparer(comparer);
specification?.EqualityRule?.GetEqualityResult(entity, entity);
Mock.Get(comparer)
.Verify(x => x.Equals(entity, entity), Times.Once);
}
IConfiguresComparison <SampleEntity> AsComparerChooser(PersistenceTestBuilder <SampleEntity> sut) => sut;
IChoosesEntityWithOptionalSetup AsSetupChooser(PersistenceTestBuilder sut) => sut;
public void WithSetup_executes_setup_within_transaction_when_no_preference_specified([Frozen] IGetsDataConnection sessionProvider,
PersistenceTestBuilder sut,
[NoRecursion] SampleEntity entity,
IDataConnection session,
IGetsTransaction tranFactory,
ITransaction tran)
{
Mock.Get(sessionProvider).Setup(x => x.GetConnection()).Returns(session);
Mock.Get(session).Setup(x => x.GetTransactionFactory()).Returns(tranFactory);
Mock.Get(tranFactory).Setup(x => x.GetTransaction()).Returns(tran);
var action = GetSetup(getter => { /* Noop */ });
var result = (PersistenceTestBuilder <SampleEntity>)AsSetupChooser(sut)
.WithSetup(action)
.WithEntity(entity);
result.Setup(session);
Mock.Get(tranFactory).Verify(x => x.GetTransaction(), Times.Once);
}
