Autofixture: рдПрдХ рдмрдпрд╛рди рдХреЗ рд╕рд╛рде рдЕрдиреБрдХреВрд▓рд┐рдд рдХрд░реЗрдВ рд▓реИрдореНрдмреНрдбрд╛ рдХрд╛рдо рдирд╣реАрдВ рдХрд░рддрд╛ рд╣реИ - рдХреНрдпрд╛ рдпрд╣ рдЕрдкреЗрдХреНрд╖рд┐рдд рд╣реИ?

рдХреЛ рдирд┐рд░реНрдорд┐рдд 7 рдЬреВрди 2018  ┬╖  2рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ  ┬╖  рд╕реНрд░реЛрдд: AutoFixture/AutoFixture

рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдкрд░реАрдХреНрд╖рдг рд╡рд┐рдлрд▓ рд░рд╣рддрд╛ рд╣реИ:

public class UnitTest1
    {
        [Fact]
        public void Test1()
        {
            var fixture = new Fixture();
            fixture.Customize<PaymentReturnPayload>(c =>
            { // a statement lambda
                c.With(a => a.OperationAmount, "1");
                c.FromFactory(() => new PaymentReturnPayload(fixture.Create<int>().ToString()));
                return c;
            });
            var paymentReturnPayload = fixture.Create<PaymentReturnPayload>();
            Assert.True(int.TryParse(paymentReturnPayload.Control, out _));
        }
    }

    public class PaymentReturnPayload
    {
        public PaymentReturnPayload(string control)
        {
            Control = control;
        }

        public string OperationAmount { get; set; }

        public string Control
        {
            get;
        }
    }

рдирд┐рдпрдВрддреНрд░рдг рдкреИрд░рд╛рдореАрдЯрд░ рдЬреЗрдирд░реЗрдЯ рдХрд┐рдП рдЧрдП int рдХреЗ рдмрдЬрд╛рдп рдпрд╛рджреГрдЪреНрдЫрд┐рдХ рд╕реНрдЯреНрд░рд┐рдВрдЧ рджреНрд╡рд╛рд░рд╛ рдкреЙрдкреНрдпреБрд▓реЗрдЯ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИред

рд╕рдВрд╕реНрдХрд░рдг 4.0 - 4.4 (рдореИрдВрдиреЗ рдкрд┐рдЫрд▓реЗ рд╡рд╛рд▓реЗ рдХрд╛ рдкрд░реАрдХреНрд╖рдг рдирд╣реАрдВ рдХрд┐рдпрд╛)
рдиреЗрдЯ рдХреЛрд░ 2.0 - 2.1

рдпрд╣ рдЕрдЪреНрдЫрд╛ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ

[Fact]
        public void Test1()
        {
            var fixture = new Fixture();
            fixture.Customize<PaymentReturnPayload>(c =>
                c.FromFactory(() => new PaymentReturnPayload(fixture.Create<int>().ToString())));
            var paymentReturnPayload = fixture.Create<PaymentReturnPayload>();
            Assert.True(int.TryParse(paymentReturnPayload.Control, out _));
        }

рдРрд╕рд╛ рд▓рдЧрддрд╛ рд╣реИ рдХрд┐ рд▓реИрдореНрдмреНрдбрд╛ рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдХрд╕реНрдЯрдорд╛рдЗрдЬрд╝ рдХрд░рдирд╛ рдХрд╛рдо рдирд╣реАрдВ рдХрд░рддрд╛ рд╣реИред
рдХреНрдпрд╛ рдпрд╣ рдЕрдкреЗрдХреНрд╖рд┐рдд рд╡реНрдпрд╡рд╣рд╛рд░ рд╣реИ?
рдФрд░ рдпрджрд┐ рд╣рд╛рдБ, рддреЛ рдХреНрдпрд╛ рдЗрд╕реЗ рдХрд┐рд╕реА рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдореЗрдВ рдирд╣реАрдВ рдЬреЛрдбрд╝рд╛ рдЬрд╛рдирд╛ рдЪрд╛рд╣рд┐рдП? рдореИрдВрдиреЗ рдпрд╣ рдкрддрд╛ рд▓рдЧрд╛рдиреЗ рдореЗрдВ рдмрд╣реБрдд рд╕рдордп рдЧрдВрд╡рд╛рдпрд╛ рдХрд┐ рдХреНрдпрд╛ рдЧрд▓рдд рд╣реИ...

рд╕рднреА 2 рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ

@progala2 рдкреНрд░рд╢реНрди рдЙрдард╛рдиреЗ рдХреЗ рд▓рд┐рдП рдзрдиреНрдпрд╡рд╛рджред

рдореМрдЬреВрджрд╛ рд╡реНрдпрд╡рд╣рд╛рд░ рдбрд┐рдЬрд╛рдЗрди рджреНрд╡рд╛рд░рд╛ рд╣реИред рдЗрд╕рдХрд╛ рдХрд╛рд░рдг рдпрд╣ рд╣реИ рдХрд┐ FromFactory , With (рдФрд░ Without ) рд╡рд┐рдзрд┐рдпрд╛рдВ рдЕрдкрд░рд┐рд╡рд░реНрддрдиреАрдп рд╣реИрдВ, рдЗрд╕рд▓рд┐рдП рд╡реЗ рдЕрдВрддрд░реНрдирд┐рд╣рд┐рдд рд╡рд╕реНрддреБ рдХреЛ рдирд╣реАрдВ рдмрджрд▓рддреЗ рд╣реИрдВред рдЗрд╕рдХреЗ рдмрдЬрд╛рдп, рд╡реЗ рдХреЙрдиреНрдлрд╝рд┐рдЧрд░ рдХрд┐рдП рдЧрдП рдЧреНрд░рд╛рдлрд╝ рдХреЗ рд╕рд╛рде рдПрдХ рдирдИ рд╡рд╕реНрддреБ рд▓реМрдЯрд╛рддреЗ рд╣реИрдВред

рдкрд╣рд▓рд╛ рдкрд░реАрдХреНрд╖рдг рдХрд╛рдо рдирд╣реАрдВ рдХрд░рдиреЗ рдХрд╛ рдХрд╛рд░рдг рдпрд╣ рд╣реИ рдХрд┐ рдЖрдк рдЖрд╣реНрд╡рд╛рди рдХреЗ рдкрд░рд┐рдгрд╛рдо рдХрд╛ рдЙрдкрдпреЛрдЧ рдирд╣реАрдВ рдХрд░рддреЗ рд╣реИрдВ, рдЗрд╕рд▓рд┐рдП рд╕рднреА рд▓рд╛рдЧреВ рдкрд░рд┐рд╡рд░реНрддрди рдЫреЛрдбрд╝ рджрд┐рдП рдЬрд╛рддреЗ рд╣реИрдВред рдПрдХ рдмрд╛рд░ рдЬрдм рдЖрдк рдХреЛрдб рдХреЛ рд╕рд╣реА рдврдВрдЧ рд╕реЗ рдлрд┐рд░ рд╕реЗ рд▓рд┐рдЦ рд▓реЗрддреЗ рд╣реИрдВ, рддреЛ рдпрд╣ рдХрдердиреЛрдВ рдХреЗ рд╕рд╛рде рднреА рдареАрдХ рдХрд╛рдо рдХрд░реЗрдЧрд╛:

```рд╕реА#
[рддрдереНрдп]
рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рд╢реВрдиреНрдп рдЯреЗрд╕реНрдЯ1 ()
{
рд╡рд░ рд╕реНрдерд┐рд░рддрд╛ = рдирдИ рд╕реНрдерд┐рд░рддрд╛ ();
рд╕реНрдерд┐рд░рддрд╛ред рдЕрдиреБрдХреВрд▓рд┐рдд рдХрд░реЗрдВ(рд╕реА =>
{
// рдПрдХ рдмрдпрд╛рди рд▓реИрдореНрдмреНрдбрд╛
var res = c.FromFactory(() => new PaymentReturnPayload(fixture.Create .)()редрддрд╛рд░()));
res = res.with(a => a.OperationAmount, "1");
рд╡рд╛рдкрд╕реА рд░реЗрд╕;
});

var paymentReturnPayload = fixture.Create<PaymentReturnPayload>();
Assert.True(int.TryParse(paymentReturnPayload.Control, out _));

}


But as you might notice, it's easier to write this code with lambda.

P.S. By the way, you can slightly improve the final code (notice the `FromFactory` has overload taking extra values necessary for the object construction):
```c#
[Fact]
public void Test3()
{
    var fixture = new Fixture();
    fixture.Customize<PaymentReturnPayload>(c =>
        c.FromFactory((int control) => new PaymentReturnPayload(control.ToString())));

    var paymentReturnPayload = fixture.Create<PaymentReturnPayload>();
    Assert.True(int.TryParse(paymentReturnPayload.Control, out _));
}

рдореИрдВ рджреЗрдЦрддрд╛ рд╣реВрдВ, рд╡реЗ рдЕрдкрд░рд┐рд╡рд░реНрддрдиреАрдп рд╣реИрдВ - рдпрд╣ рдЕрдм рдмрд╣реБрдд рд╕реНрдкрд╖реНрдЯ рд╣реИред
рдЖрдкрдХреЗ рдЙрддреНрддрд░ рдФрд░ рдХреБрдЫ рдЕрддрд┐рд░рд┐рдХреНрдд рдпреБрдХреНрддрд┐рдпреЛрдВ рдХреЗ рд▓рд┐рдП рдзрдиреНрдпрд╡рд╛рдж!

рдХреНрдпрд╛ рдпрд╣ рдкреГрд╖реНрда рдЙрдкрдпреЛрдЧреА рдерд╛?
0 / 5 - 0 рд░реЗрдЯрд┐рдВрдЧреНрд╕

рд╕рдВрдмрдВрдзрд┐рдд рдореБрджреНрджреЛрдВ

Ridermansb picture Ridermansb  ┬╖  4рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ

TroyHouston picture TroyHouston  ┬╖  6рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ

gtbuchanan picture gtbuchanan  ┬╖  3рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ

zvirja picture zvirja  ┬╖  3рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ

joelleortiz picture joelleortiz  ┬╖  4рдЯрд┐рдкреНрдкрдгрд┐рдпрд╛рдБ