public void WithAutoPropertiesFalseReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
// Act
var actual = sut.WithAutoProperties(false);
// Assert
var expected = sut;
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void ComposeSingleItemReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <GenericUriParser>();
var expected = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.Compose(new[] { expected });
// Verify outcome
var f = Assert.IsAssignableFrom <NodeComposer <GenericUriParser> >(actual);
Assert.Equal(expected, f.Builder);
// Teardown
}
public void OmitAutoPropertiesIsInitiallyANoOp()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
// Act
var actual = sut.OmitAutoProperties();
// Assert
var expected = sut;
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void SutIsCorrectInitialGraph()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <int>();
// Exercise system
// Verify outcome
var factory = new MethodInvoker(new ModestConstructorQuery());
var expected = new NodeComposer <int>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(int), factory));
Assert.True(expected.GraphEquals(sut, new NodeComparer()));
// Teardown
}
public void ComposeWithoutCorrectlyCreatesSpecimen()
{
// Arrange
var builder = new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoubleFieldHolder <string, int> >().WithAutoProperties().Without(x => x.Field1),
Scenario.CreateCoreBuilder());
// Act
var result = new SpecimenContext(builder).Create <DoubleFieldHolder <string, int> >();
// Assert
Assert.Null(result.Field1);
Assert.Equal(1, result.Field2);
}
public void CustomDoSetsCorrectProperty()
{
// Fixture setup
var builder = new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <decimal> >().OmitAutoProperties().Do(x => x.SetProperty(6789)),
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).Create <SingleParameterType <PropertyHolder <decimal> > >();
// Verify outcome
Assert.Equal(6789, result.Parameter.Property);
// Teardown
}
public void CustomizeAndComposeComplexType()
{
// Arrange
// Act
var result = new CompositeNodeComposer <DoublePropertyHolder <int, decimal> >(
new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, decimal> >(),
Scenario.CreateAutoPropertyBuilder()))
.With(x => x.Property2, 8m).WithAutoProperties().Create();
// Assert
Assert.Equal(1, result.Property1);
Assert.Equal(8, result.Property2);
}
/// <summary>
/// Customizes the fixture by creating a <see cref="targetType"/> that has no auto populated properties.
/// </summary>
/// <param name="fixture">The fixture to customize.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="fixture"/> is null.
/// </exception>
public void Customize(IFixture fixture)
{
if (fixture == null)
{
throw new ArgumentNullException("fixture");
}
var constructor = new MethodInvoker(new ModestConstructorQuery());
var builder = SpecimenBuilderNodeFactory.CreateTypedNode(
this.targetType, constructor);
fixture.Customizations.Insert(0, builder);
}
public void ComposeWithoutCorrectlyCreatesSpecimen()
{
// Fixture setup
var builder = new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoubleFieldHolder <string, int> >().WithAutoProperties().Without(x => x.Field1),
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).Create <DoubleFieldHolder <string, int> >();
// Verify outcome
Assert.Null(result.Field1);
Assert.Equal(1, result.Field2);
// Teardown
}
public void TogglingAutoPropertiesOnAndOffReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
// Exercise system
var actual = sut.WithAutoProperties(true).WithAutoProperties(false);
// Verify outcome
var expected = sut;
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
/// <summary>
/// Customizes the specified fixture by modifying <see cref="TargetType"/> to use
/// <see cref="Query"/> as the strategy for creating new specimens.
/// </summary>
/// <param name="fixture">The fixture to customize.</param>
public void Customize(IFixture fixture)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
var factory = new MethodInvoker(this.Query);
var builder = SpecimenBuilderNodeFactory.CreateTypedNode(
this.TargetType,
factory);
fixture.Customizations.Insert(0, builder);
}
public void OmitAutoPropertiesIsInitiallyANoOp()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
// Exercise system
var actual = sut.OmitAutoProperties();
// Verify outcome
var expected = sut;
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void ComposeWithValueReturnsCorrectResult()
{
// Arrange
var expectedValue = 9;
var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >()
.With(x => x.Property, expectedValue);
var builder = new CompositeSpecimenBuilder(
customBuilder,
Scenario.CreateCoreBuilder());
// Act
var result = new SpecimenContext(builder).Create <PropertyHolder <int> >();
// Assert
Assert.Equal(expectedValue, result.Property);
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <Guid>();
var builder = new DelegatingSpecimenBuilder();
// Act
var actual = sut.FromFactory(builder);
// Assert
var expected = new NodeComposer <Guid>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Guid), builder));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void ComposeWithAutoProperties()
{
// Arrange
var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, int> >()
.WithAutoProperties();
var builder = new CompositeSpecimenBuilder(
customBuilder,
Scenario.CreateCoreBuilder());
// Act
var result = new SpecimenContext(builder).Create <DoublePropertyHolder <int, int> >();
// Assert
Assert.Equal(1, result.Property1);
Assert.Equal(2, result.Property2);
}
public void CreateComposerReturnsCorrectResult()
{
// Arrange
// Act
NodeComposer <int> actual =
SpecimenBuilderNodeFactory.CreateComposer <int>();
// Assert
var expected = new NodeComposer <int>(
SpecimenBuilderNodeFactory.CreateTypedNode(
typeof(int),
new MethodInvoker(
new ModestConstructorQuery())));
Assert.True(expected.GraphEquals(actual, new NodeComparer()));
}
public void CustomizeAndComposeComplexType()
{
// Fixture setup
// Exercise system
var result = new CompositeNodeComposer <DoublePropertyHolder <int, decimal> >(
new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, decimal> >(),
Scenario.CreateAutoPropertyBuilder()
)
).With(x => x.Property2, 8m).WithAutoProperties().Create();
// Verify outcome
Assert.Equal(1, result.Property1);
Assert.Equal(8, result.Property2);
// Teardown
}
public void ComposeWithAutoProperties()
{
// Fixture setup
var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, int> >()
.WithAutoProperties();
var builder = new CompositeSpecimenBuilder(
customBuilder,
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).Create <DoublePropertyHolder <int, int> >();
// Verify outcome
Assert.Equal(1, result.Property1);
Assert.Equal(2, result.Property2);
// Teardown
}
public void FromTripleArgFuncReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <decimal>();
Func <int, Guid, Version, decimal> f = (i, g, v) => i;
// Act
var actual = sut.FromFactory(f);
// Assert
var factory = new SpecimenFactory <int, Guid, Version, decimal>(f);
var expected = new NodeComposer <decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <Guid>();
var builder = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.FromFactory(builder);
// Verify outcome
var expected = new NodeComposer <Guid>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Guid), builder));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void CreateComposerReturnsCorrectResult()
{
// Fixture setup
// Exercise system
NodeComposer <int> actual =
SpecimenBuilderNodeFactory.CreateComposer <int>();
// Verify outcome
var expected = new NodeComposer <int>(
SpecimenBuilderNodeFactory.CreateTypedNode(
typeof(int),
new MethodInvoker(
new ModestConstructorQuery())));
Assert.True(expected.GraphEquals(actual, new NodeComparer()));
// Teardown
}
public void FromSeedReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <decimal>();
Func <decimal, decimal> f = d => d;
// Act
var actual = sut.FromSeed(f);
// Assert
var factory = new SeededFactory <decimal>(f);
var expected = new NodeComposer <decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
Func <int, int, int, int, Version> f = (mj, mn, b, r) => new Version(mj, mn, b, r);
// Act
var actual = sut.FromFactory(f);
// Assert
var factory = new SpecimenFactory <int, int, int, int, Version>(f);
var expected = new NodeComposer <Version>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Version), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void ComposeWithValueReturnsCorrectResult()
{
// Fixture setup
var expectedValue = 9;
var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >()
.With(x => x.Property, expectedValue);
var builder = new CompositeSpecimenBuilder(
customBuilder,
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).Create <PropertyHolder <int> >();
// Verify outcome
Assert.Equal(expectedValue, result.Property);
// Teardown
}
public void FromSingleArgFuncReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <float>();
Func <int, float> f = i => i;
// Act
var actual = sut.FromFactory(f);
// Assert
var factory = new SpecimenFactory <int, float>(f);
var expected = new NodeComposer <float>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(float), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void CustomizeFromFactoryCorrectlyResolvesSpecimen()
{
// Arrange
var instance = new PropertyHolder <float> {
Property = 89
};
var builder = new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <float> >().FromFactory(() => instance).OmitAutoProperties(),
Scenario.CreateCoreBuilder());
// Act
var result = new SpecimenContext(builder).Create <PropertyHolder <float> >();
// Assert
Assert.Equal(instance, result);
Assert.Equal(89, result.Property);
}
public void FromDoubleArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <string>();
Func <int, Version, string> f = (i, _) => i.ToString();
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var factory = new SpecimenFactory <int, Version, string>(f);
var expected = new NodeComposer <string>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(string), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void ComposeWithValueFactoryReturnsCorrectResult()
{
// Arrange
var values = new Queue <string>(new[] { "value1", "value2" });
var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >()
.With(x => x.Property, () => values.Dequeue());
var builder = new CompositeSpecimenBuilder(
customBuilder,
Scenario.CreateCoreBuilder());
// Act
var result1 = new SpecimenContext(builder).Create <PropertyHolder <string> >();
var result2 = new SpecimenContext(builder).Create <PropertyHolder <string> >();
// Assert
Assert.Equal("value1", result1.Property);
Assert.Equal("value2", result2.Property);
}
public void FromSeedReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <decimal>();
Func <decimal, decimal> f = d => d;
// Exercise system
var actual = sut.FromSeed(f);
// Verify outcome
var factory = new SeededFactory <decimal>(f);
var expected = new NodeComposer <decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void CustomizeFromFactoryCorrectlyResolvesSpecimen()
{
// Fixture setup
var instance = new PropertyHolder <float> {
Property = 89
};
var builder = new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <float> >().FromFactory(() => instance).OmitAutoProperties(),
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).Create <PropertyHolder <float> >();
// Verify outcome
Assert.Equal(instance, result);
Assert.Equal(89, result.Property);
// Teardown
}
