public void CreateWillCorrectRaiseSpecimenCreatedInCompositeRequest()
{
// Arrange
object request = "The request";
object subRequest = "Some sub request";
var createdSpecimen = new object();
var spy = new List <SpecimenCreatedEventArgs>();
var builder2 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == request?c.Resolve(subRequest) : new NoSpecimen()
};
var builder3 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == subRequest ? createdSpecimen : new NoSpecimen()
};
var compBuilder = new CompositeSpecimenBuilder(builder2, builder3);
var sut = new DelegatingTracingBuilder(compBuilder);
sut.SpecimenCreated += (sender, e) => spy.Add(e);
var container = new SpecimenContext(sut);
// Act
sut.Create(request, container);
// Assert
Assert.Equal(2, spy.Count);
Assert.Equal(createdSpecimen, spy[0].Specimen);
Assert.Equal(2, spy[0].Depth);
Assert.Equal(createdSpecimen, spy[1].Specimen);
Assert.Equal(1, spy[1].Depth);
}
public void CreateWillCorrectlyRaiseSpecimenRequestedInCompositeRequest()
{
// Fixture setup
object requestedObject = "The request";
object subRequest = "Some sub request";
var spy = new List <RequestTraceEventArgs>();
var builder2 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == requestedObject?c.Resolve(subRequest) : new NoSpecimen()
};
var builder3 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == subRequest ? new object() : new NoSpecimen()
};
var compBuilder = new CompositeSpecimenBuilder(builder2, builder3);
var sut = new DelegatingTracingBuilder(compBuilder);
sut.SpecimenRequested += (sender, e) => spy.Add(e);
var container = new SpecimenContext(sut);
// Exercise system
sut.Create(requestedObject, container);
// Verify outcome
Assert.Equal(2, spy.Count);
Assert.Equal(subRequest, spy[1].Request);
Assert.Equal(2, spy[1].Depth);
// Teardown
}
/// <summary>
/// Registers that a writable property or field should be assigned a
/// specific value as part of specimen post-processing.
/// </summary>
/// <typeparam name="TProperty">
/// The type of the property of field.
/// </typeparam>
/// <param name="propertyPicker">
/// An expression that identifies the property or field that will have
/// <paramref name="value"/> assigned.
/// </param>
/// <param name="value">
/// The value to assign to the property or field identified by
/// <paramref name="propertyPicker"/>.
/// </param>
/// <returns>
/// An <see cref="IPostprocessComposer{T}"/> which can be used to
/// further customize the post-processing of created specimens.
/// </returns>
public IPostprocessComposer <T> With <TProperty>(
Expression <Func <T, TProperty> > propertyPicker, TProperty value)
{
var graphWithoutSeedIgnoringRelay =
this.WithoutSeedIgnoringRelay();
var container = FindContainer(graphWithoutSeedIgnoringRelay);
var graphWithProperty = graphWithoutSeedIgnoringRelay.ReplaceNodes(
with: n => n.Compose(
new ISpecimenBuilder[]
{
new Postprocessor <T>(
CompositeSpecimenBuilder.ComposeIfMultiple(n),
new BindingCommand <T, TProperty>(propertyPicker, value),
CreateSpecification()),
new SeedIgnoringRelay()
}),
when: container.Equals);
return((NodeComposer <T>)graphWithProperty.ReplaceNodes(
with: n => n.Compose(
new []
{
new Omitter(
new EqualRequestSpecification(
propertyPicker.GetWritableMember().Member,
new MemberInfoEqualityComparer()))
}
.Concat(n)),
when: n => n is NodeComposer <T>));
}
public void CreateDoubleMixedParameterizedTypeWithNumberBasedStringGeneratorObsolete()
{
// Fixture setup
var intGenerator = new Int32SequenceGenerator();
var builder = new CompositeSpecimenBuilder(
intGenerator,
new StringGenerator(() => intGenerator.CreateAnonymous()),
new Int64SequenceGenerator(),
new DecimalSequenceGenerator(),
new BooleanSwitch(),
new GuidGenerator(),
new MethodInvoker(new ModestConstructorQuery()),
new ParameterRequestRelay(),
new StringSeedRelay(),
new SeedIgnoringRelay());
var container = new SpecimenContext(builder);
// Exercise system
var result = (TripleParameterType <int, string, int>)container.Resolve(typeof(TripleParameterType <int, string, int>));
// Verify outcome
Assert.Equal(1, result.Parameter1);
Assert.Equal("parameter22", result.Parameter2);
Assert.Equal(3, result.Parameter3);
// Teardown
}
public void CreateWillReturnNoSpecimenIfAllBuildersReturnNoSpecimen()
{
// Fixture setup
var builders = new ISpecimenBuilder[]
{
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
},
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
},
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
}
};
var sut = new CompositeSpecimenBuilder(builders);
// Exercise system
var anonymousRequest = new object();
var dummyContainer = new DelegatingSpecimenContext();
var result = sut.Create(anonymousRequest, dummyContainer);
// Verify outcome
var expected = new NoSpecimen(anonymousRequest);
Assert.Equal(expected, result);
// Teardown
}
public void FromSingleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <ulong>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <string>(node);
Func <int, string> f = i => i.ToString();
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <string>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <string>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <ulong>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <string>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
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 expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
/// <summary>
/// Add the customization for a NullBuilder to the given <see cref="IFixture" />.
/// </summary>
/// <param name="fixture">
/// The <see cref="IFixture" /> to be customized.
/// </param>
public void Customize(IFixture fixture)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
var fixedBuilder = new NullBuilder( );
var types = new []
{
TargetType,
RegisteredType
};
var specimenBuilders = from t in types
select SpecimenBuilderNodeFactory.CreateTypedNode(t,
fixedBuilder)
as ISpecimenBuilder;
var builder = new CompositeSpecimenBuilder(specimenBuilders);
fixture.Customizations
.Insert(0,
builder);
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <decimal>(node);
var factory = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.FromFactory(factory);
// Verify outcome
var expected = new CompositeNodeComposer <decimal>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void ComposeComplexObjectWithAutoPropertiesAndSomeCustomizations()
{
// Fixture setup
var builder = new CompositeSpecimenBuilder(
new Composer <DoublePropertyHolder <long, long> >()
.With(x => x.Property2, 43)
.WithAutoProperties()
.Compose(),
new Composer <DoublePropertyHolder <int, string> >()
.OmitAutoProperties()
.With(x => x.Property1)
.Compose(),
new Composer <DoublePropertyHolder <DoublePropertyHolder <long, long>, DoublePropertyHolder <int, string> > >()
.WithAutoProperties()
.Compose(),
Scenario.CreateCoreBuilder());
// Exercise system
var result = new SpecimenContext(builder).CreateAnonymous <DoublePropertyHolder <DoublePropertyHolder <long, long>, DoublePropertyHolder <int, string> > >();
// Verify outcome
Assert.Equal(1, result.Property1.Property1);
Assert.Equal(43, result.Property1.Property2);
Assert.Equal(1, result.Property2.Property1);
Assert.Null(result.Property2.Property2);
// Teardown
}
/// <summary>Composes the supplied builders.</summary>
/// <param name="builders">The builders to compose.</param>
/// <returns>
/// A new <see cref="ISpecimenBuilderNode" /> instance containing
/// <paramref name="builders" /> as child nodes.
/// </returns>
public ISpecimenBuilderNode Compose(IEnumerable <ISpecimenBuilder> builders)
{
var composedBuilder =
CompositeSpecimenBuilder.ComposeIfMultiple(builders);
return(new ResidueCollectorNode(composedBuilder));
}
/// <summary>Composes the supplied builders.</summary>
/// <param name="builders">The builders to compose.</param>
/// <returns>
/// A new <see cref="ISpecimenBuilderNode" /> instance containing
/// <paramref name="builders" /> as child nodes.
/// </returns>
public ISpecimenBuilderNode Compose(IEnumerable <ISpecimenBuilder> builders)
{
var composedBuilder =
CompositeSpecimenBuilder.ComposeIfMultiple(builders);
return(new CustomizationNode(composedBuilder));
}
public void CreateWillInvokeBuilderWithCorrectContainer()
{
// Arrange
var expectedContainer = new DelegatingSpecimenContext();
var mockVerified = false;
var builderMock = new DelegatingSpecimenBuilder();
builderMock.OnCreate = (r, c) =>
{
if (expectedContainer != c)
{
throw new ArgumentException("Invalid context");
}
mockVerified = true;
return(new object());
};
var sut = new CompositeSpecimenBuilder(builderMock);
// Act
var dummyRequest = new object();
sut.Create(dummyRequest, expectedContainer);
// Assert
Assert.True(mockVerified, "Mock verification");
}
public void WithSingleArgValueFactoryReturnsCorrectResult(string value)
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <PropertyHolder <string> >(node);
Func <string, string> valueFactory = _ => value;
// Act
var actual = sut.With(x => x.Property, valueFactory);
// Assert
var expected = new CompositeNodeComposer <PropertyHolder <string> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, valueFactory),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, valueFactory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <decimal>(node);
var factory = new DelegatingSpecimenBuilder();
// Act
var actual = sut.FromFactory(factory);
// Assert
var expected = new CompositeNodeComposer <decimal>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromDoubleArgFuncReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
Func <int, int, Version> f = (mj, mn) => new Version(mj, mn);
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromNoArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
SpecimenBuilderNodeFactory.CreateComposer <float>(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Guid>(node);
Func <Guid> f = () => Guid.Empty;
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <Guid>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Guid>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <float>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Guid>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void DoReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>(),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <AppDomainSetup>(node);
Action <AppDomainSetup> a =
ads => ads.DisallowApplicationBaseProbing = false;
// Exercise system
var actual = sut.Do(a);
// Verify outcome
var expected = new CompositeNodeComposer <AppDomainSetup>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>().Do(a),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>().Do(a),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromTripleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <long>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <long>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <long>(node);
Func <long, int, short, long> f = (x, y, z) => x;
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <long>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <long>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <long>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void OmitAutoPropertiesAfterAddingAutoPropertiesReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
// Exercise system
var actual = sut.WithAutoProperties().OmitAutoProperties();
// Verify outcome
var expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().WithAutoProperties().OmitAutoProperties(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().WithAutoProperties().OmitAutoProperties(),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void DoReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>(),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <ConcreteType>(node);
Action <ConcreteType> a =
ads => ads.Property1 = null;
// Act
var actual = sut.Do(a);
// Assert
var expected = new CompositeNodeComposer <ConcreteType>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>().Do(a),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>().Do(a),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void WithExplicitValueReturnsCorrectResult(string value)
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <PropertyHolder <string> >(node);
// Exercise system
var actual = sut.With(x => x.Property, value);
// Verify outcome
var expected = new CompositeNodeComposer <PropertyHolder <string> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, value),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, value),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
/// <summary>Composes the supplied builders.</summary>
/// <param name="builders">The builders to compose.</param>
/// <returns>
/// A new <see cref="ISpecimenBuilderNode" /> instance containing
/// <paramref name="builders" /> as child nodes.
/// </returns>
public ISpecimenBuilderNode Compose(IEnumerable <ISpecimenBuilder> builders)
{
var composedBuilder =
CompositeSpecimenBuilder.ComposeIfMultiple(builders);
return(new AutoPropertiesTarget(composedBuilder));
}
public void WithoutReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >(),
SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <FieldHolder <short> >(node);
// Exercise system
var actual = sut.Without(x => x.Field);
// Verify outcome
var expected = new CompositeNodeComposer <FieldHolder <short> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >().Without(x => x.Field),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >().Without(x => x.Field),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void CreateWillTrackCreatedSpecimensComposite()
{
// Fixture setup
object requestedObject = "The request";
object subRequest = "Some sub request";
object createdSpecimen = Guid.NewGuid();
var spy = new List <object>();
var builder2 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == requestedObject?c.Resolve(subRequest) : new NoSpecimen()
};
var builder3 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == subRequest ? createdSpecimen : new NoSpecimen()
};
var compBuilder = new CompositeSpecimenBuilder(builder2, builder3);
var sut = new DelegatingTracingBuilder(compBuilder);
sut.SpecimenCreated += (sender, e) => spy.Add(e.Specimen);
var container = new SpecimenContext(sut);
// Exercise system
sut.Create(requestedObject, container);
// Verify outcome
Assert.Equal(2, spy.Count);
Assert.Equal(createdSpecimen, spy[0]);
Assert.Equal(createdSpecimen, spy[1]);
// Teardown
}
public void GraphEqualsNullFirstThrows()
{
var dummyNode = new CompositeSpecimenBuilder();
Assert.Throws <ArgumentNullException>(() =>
SpecimenBuilderNode.GraphEquals(null, dummyNode));
}
/// <summary>Composes the supplied builders.</summary>
/// <param name="builders">The builders to compose.</param>
/// <returns>
/// A new <see cref="ISpecimenBuilderNode" /> instance containing
/// <paramref name="builders" /> as child nodes.
/// </returns>
public ISpecimenBuilderNode Compose(IEnumerable <ISpecimenBuilder> builders)
{
var composedBuilder =
CompositeSpecimenBuilder.ComposeIfMultiple(builders);
return(new BehaviorRoot(composedBuilder));
}
public void CreateWillReturnNoSpecimenIfAllBuildersReturnNoSpecimen()
{
// Arrange
var builders = new ISpecimenBuilder[]
{
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
},
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
},
new DelegatingSpecimenBuilder {
OnCreate = (r, c) => new NoSpecimen()
}
};
var sut = new CompositeSpecimenBuilder(builders);
// Act
var anonymousRequest = new object();
var dummyContainer = new DelegatingSpecimenContext();
var result = sut.Create(anonymousRequest, dummyContainer);
// Assert
var expected = new NoSpecimen();
Assert.Equal(expected, result);
}
public void CombineExplicitPropertyWithAutoProperties()
{
// Arrange
var expectedText = "Fnaah";
var specifiedCommand = new BindingCommand <DoublePropertyHolder <string, int>, string>(ph => ph.Property1, expectedText);
var reservedProperty = new InverseRequestSpecification(specifiedCommand);
var customizedBuilder = new Postprocessor(
new Postprocessor(
new MethodInvoker(new ModestConstructorQuery()),
specifiedCommand),
new AutoPropertiesCommand(reservedProperty),
new AnyTypeSpecification());
var builder = new CompositeSpecimenBuilder(
customizedBuilder,
Scenario.CreateAutoPropertyBuilder());
var container = new SpecimenContext(builder);
// Act
var result = container.Resolve(typeof(DoublePropertyHolder <string, int>));
// Assert
var actual = Assert.IsAssignableFrom <DoublePropertyHolder <string, int> >(result);
Assert.Equal(expectedText, actual.Property1);
Assert.Equal(1, actual.Property2);
}
public void CreateWillTrackCompositeRequests()
{
// Arrange
object requestedObject = "The request";
object subRequest = "Some sub request";
var spy = new List <object>();
var builder2 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == requestedObject?c.Resolve(subRequest) : new NoSpecimen()
};
var builder3 = new DelegatingSpecimenBuilder {
OnCreate = (r, c) => r == subRequest ? new object() : new NoSpecimen()
};
var compBuilder = new CompositeSpecimenBuilder(builder2, builder3);
var sut = new DelegatingTracingBuilder(compBuilder);
sut.SpecimenRequested += (sender, e) => spy.Add(e.Request);
var container = new SpecimenContext(sut);
// Act
sut.Create(requestedObject, container);
// Assert
Assert.Equal(2, spy.Count);
Assert.Equal(subRequest, spy[1]);
}
