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 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 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 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 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 ComposeWithAutoPropertiesAndExplicitProperty() { // Arrange var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, int> >() .WithAutoProperties() .With(x => x.Property1, 8); var builder = new CompositeSpecimenBuilder( customBuilder, Scenario.CreateCoreBuilder()); // Act var result = new SpecimenContext(builder).Create <DoublePropertyHolder <int, int> >(); // Assert Assert.Equal(8, result.Property1); Assert.Equal(1, result.Property2); }
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 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 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 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 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 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 }
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 ComposeReturnsCorrectResult() { // Arrange var sut = SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>(); // Act var expectedBuilders = new[] { new DelegatingSpecimenBuilder(), new DelegatingSpecimenBuilder(), new DelegatingSpecimenBuilder() }; var actual = sut.Compose(expectedBuilders); // Assert var nc = Assert.IsAssignableFrom <NodeComposer <ConcreteType> >(actual); var composite = Assert.IsAssignableFrom <CompositeSpecimenBuilder>(nc.Builder); Assert.True(expectedBuilders.SequenceEqual(composite)); }
public void ComposeReturnsCorrectResult() { // Fixture setup var sut = SpecimenBuilderNodeFactory.CreateComposer <GenericUriParser>(); // Exercise system var expectedBuilders = new[] { new DelegatingSpecimenBuilder(), new DelegatingSpecimenBuilder(), new DelegatingSpecimenBuilder() }; var actual = sut.Compose(expectedBuilders); // Verify outcome var nc = Assert.IsAssignableFrom <NodeComposer <GenericUriParser> >(actual); var composite = Assert.IsAssignableFrom <CompositeSpecimenBuilder>(nc.Builder); Assert.True(expectedBuilders.SequenceEqual(composite)); // Teardown }
public void ComposeWithSingleArgumentValueFactoryReturnsCorrectResult() { // Arrange var values = new Queue <string>(new[] { "value1", "value2" }); var customBuilder = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >() .With(x => x.Property, (Queue <string> v) => v.Dequeue()); var builder = new CompositeSpecimenBuilder( customBuilder, new FilteringSpecimenBuilder( new FixedBuilder(values), new ExactTypeSpecification(typeof(Queue <string>))), 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 WithExplicitValueReturnsCorrectResult(string value) { // Fixture setup var sut = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(); var pi = typeof(PropertyHolder <string>).GetProperty("Property"); // Exercise system var actual = sut.With(x => x.Property, value); // Verify outcome var expected = new NodeComposer <PropertyHolder <string> >( new FilteringSpecimenBuilder( new CompositeSpecimenBuilder( new Postprocessor( new Postprocessor( new NoSpecimenOutputGuard( new MethodInvoker( new ModestConstructorQuery()), new InverseRequestSpecification( new SeedRequestSpecification( typeof(PropertyHolder <string>)))), new AutoPropertiesCommand( typeof(PropertyHolder <string>), new InverseRequestSpecification( new EqualRequestSpecification( pi, new MemberInfoEqualityComparer()))), new FalseRequestSpecification() ), new BindingCommand <PropertyHolder <string>, string>(x => x.Property, value), new OrRequestSpecification( new SeedRequestSpecification(typeof(PropertyHolder <string>)), new ExactTypeSpecification(typeof(PropertyHolder <string>)))), new SeedIgnoringRelay()), new OrRequestSpecification( new SeedRequestSpecification(typeof(PropertyHolder <string>)), new ExactTypeSpecification(typeof(PropertyHolder <string>))))); var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual); Assert.True(expected.GraphEquals(n, new NodeComparer())); // Teardown }
public void WithExplicitSingleArgValueFactoryReturnsCorrectResult() { // Arrange var sut = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(); var pi = typeof(PropertyHolder <string>).GetProperty("Property"); Func <string, string> valueFactory = v => v; // Act var actual = sut.With(x => x.Property, valueFactory); // Assert var expected = new NodeComposer <PropertyHolder <string> >( new FilteringSpecimenBuilder( new CompositeSpecimenBuilder( new Postprocessor( new Postprocessor( new NoSpecimenOutputGuard( new MethodInvoker( new ModestConstructorQuery()), new InverseRequestSpecification( new SeedRequestSpecification( typeof(PropertyHolder <string>)))), new AutoPropertiesCommand( typeof(PropertyHolder <string>), new InverseRequestSpecification( new EqualRequestSpecification( pi, new MemberInfoEqualityComparer()))), new FalseRequestSpecification()), new BindingCommand <PropertyHolder <string>, string>(x => x.Property, ctx => valueFactory((string)ctx.Resolve(typeof(string)))), new OrRequestSpecification( new SeedRequestSpecification(typeof(PropertyHolder <string>)), new ExactTypeSpecification(typeof(PropertyHolder <string>)))), new SeedIgnoringRelay()), new OrRequestSpecification( new SeedRequestSpecification(typeof(PropertyHolder <string>)), new ExactTypeSpecification(typeof(PropertyHolder <string>))))); var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual); Assert.True(expected.GraphEquals(n, new NodeComparer())); }
public void ComposeComplexObjectWithAutoPropertiesAndSomeCustomizations() { // Arrange var builder = new CompositeSpecimenBuilder( SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <long, long> >() .With(x => x.Property2, 43) .WithAutoProperties(), SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, string> >() .OmitAutoProperties() .With(x => x.Property1), SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <DoublePropertyHolder <long, long>, DoublePropertyHolder <int, string> > >() .WithAutoProperties(), Scenario.CreateCoreBuilder()); // Act var result = new SpecimenContext(builder).Create <DoublePropertyHolder <DoublePropertyHolder <long, long>, DoublePropertyHolder <int, string> > >(); // Assert Assert.Equal(1, result.Property1.Property1); Assert.Equal(43, result.Property1.Property2); Assert.Equal(1, result.Property2.Property1); Assert.Null(result.Property2.Property2); }
public void ComposeComplexObjectWithAutoPropertiesAndSomeCustomizations() { // Fixture setup var builder = new CompositeSpecimenBuilder( SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <long, long> >() .With(x => x.Property2, 43) .WithAutoProperties(), SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, string> >() .OmitAutoProperties() .With(x => x.Property1), SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <DoublePropertyHolder <long, long>, DoublePropertyHolder <int, string> > >() .WithAutoProperties(), Scenario.CreateCoreBuilder()); // Exercise system var result = new SpecimenContext(builder).Create <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 }
public void WithoutReturnsCorrectResult() { // Arrange 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); // Act var actual = sut.Without(x => x.Field); // Assert 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())); }
public void OmitAutoPropertiesAfterAddingAutoPropertiesReturnsCorrectResult() { // Arrange var node = new CompositeSpecimenBuilder( new DelegatingSpecimenBuilder(), SpecimenBuilderNodeFactory.CreateComposer <Version>(), SpecimenBuilderNodeFactory.CreateComposer <string>(), SpecimenBuilderNodeFactory.CreateComposer <Version>(), new DelegatingSpecimenBuilder()); var sut = new CompositeNodeComposer <Version>(node); // Act var actual = sut.WithAutoProperties().OmitAutoProperties(); // Assert 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())); }
public void WithExplicitValueReturnsCorrectResult(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); // Act var actual = sut.With(x => x.Property, value); // Assert 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())); }