Hi,
```C#
[TestFixture]
öffentliche Klasse TestAutoFixture {
public class TestClass
{
public string Property { get; set; }
}
[Test]
public void Test()
{
var f = new Fixture();
f.Customize<TestClass>(composer => composer.FromFactory(() => new TestClass { Property = "foobar" }));
var o = f.Create<TestClass>();
Assert.That(o.Property, Is.EqualTo("foobar"));
}
}
```
Dieser Test schlägt bei Verwendung von 4.0.0-rc1 auf .NET Core 2 fehl
Ich denke, dies ist entweder irreführend (oder schlecht dokumentiert) oder defekt .
EDIT: Es ist nicht kaputt, siehe Kommentare unten.
Mir ist aufgefallen, dass es wie beabsichtigt funktioniert, wenn ich .Without(_ => _.Property)
nach der Methode FromFactory
hinzufüge.
Ich denke, dass dies sehr kontraintuitiv ist, aber da es sich nicht um einen Fehler handelt, können wir dies schließen.
Nun, es ist wahrscheinlich ein Problem mit unserer Dokumentation ☺️
Standardmäßig füllt AutoFixture Eigenschaften automatisch mit öffentlichen Settern auf, es sei denn, Sie deaktivieren dieses Verhalten, indem Sie fixture.OmitAutoProperties = true
festlegen. Mit der Methode composer.FromFactory()
können Sie festlegen, wie die Instanz des jeweiligen Typs aktiviert wird, die Eigenschaften werden dem Objekt jedoch später noch zugewiesen.
Tatsächlich hängt die richtige Verwendung der AutoFixture-API vom Szenario ab. Die "idiomatischste" Verwendung im obigen Szenario wäre die folgende:
```c#
f.Anpassen
.FromFactory(() => neue Testklasse())
.With(x => x.Eigenschaft, "foobar"));
or even the simplified one as AutoFixture will automatically pick up that constructor:
```c#
f.Customize<TestClass>(c => c
.With(x => x.Property, "foobar"));
Alternativ können Sie bei Bedarf einfach die automatische Eigenschaftsauffüllung deaktivieren:
```c#
f.Anpassen
.FromFactory(() => new TestClass { Property = "foobar" })
.OmitAutoProperties());
However, in this case, probably, the `Customize<>()` API is an overhead. Instead, it's simpler to use the `fixture.Register()` method as it allows to use the constructed instance "as-is" without any post-processing:
```c#
f.Register(() => new TestClass { Property = "foobar" });
Es mag am Anfang verwirrend sein zu verstehen, welche genaue API besser passt, aber später sollte es einfacher werden 😉All diese API bietet die Flexibilität und in verschiedenen Szenarien sehen die verschiedenen Optionen besser aus.
Lassen Sie es mich wissen, wenn Sie noch Fragen zu klären haben und ich helfe Ihnen gerne weiter.
PS Die folgenden Links könnten auch helfen:
PPS Der Grund, warum composer.Without(x => x.Property)
funktioniert, ist, dass dieser Ausdruck die automatischen Eigenschaften für die bestimmte Eigenschaft/das Feld deaktiviert. In diesem Fall überschreibt AutoFixture den anfänglichen Objektwert nicht mit dem automatisch generierten.
Vielen Dank für diese unglaubliche Antwort! Du bist fantastisch :)
Hilfreichster Kommentar
Nun, es ist wahrscheinlich ein Problem mit unserer Dokumentation ☺️
Standardmäßig füllt AutoFixture Eigenschaften automatisch mit öffentlichen Settern auf, es sei denn, Sie deaktivieren dieses Verhalten, indem Sie
fixture.OmitAutoProperties = true
festlegen. Mit der Methodecomposer.FromFactory()
können Sie festlegen, wie die Instanz des jeweiligen Typs aktiviert wird, die Eigenschaften werden dem Objekt jedoch später noch zugewiesen.Tatsächlich hängt die richtige Verwendung der AutoFixture-API vom Szenario ab. Die "idiomatischste" Verwendung im obigen Szenario wäre die folgende:
```c#(c => c
f.Anpassen
.FromFactory(() => neue Testklasse())
.With(x => x.Eigenschaft, "foobar"));
Alternativ können Sie bei Bedarf einfach die automatische Eigenschaftsauffüllung deaktivieren:(c => c
```c#
f.Anpassen
.FromFactory(() => new TestClass { Property = "foobar" })
.OmitAutoProperties());
Es mag am Anfang verwirrend sein zu verstehen, welche genaue API besser passt, aber später sollte es einfacher werden 😉All diese API bietet die Flexibilität und in verschiedenen Szenarien sehen die verschiedenen Optionen besser aus.
Lassen Sie es mich wissen, wenn Sie noch Fragen zu klären haben und ich helfe Ihnen gerne weiter.
PS Die folgenden Links könnten auch helfen:
PPS Der Grund, warum
composer.Without(x => x.Property)
funktioniert, ist, dass dieser Ausdruck die automatischen Eigenschaften für die bestimmte Eigenschaft/das Feld deaktiviert. In diesem Fall überschreibt AutoFixture den anfänglichen Objektwert nicht mit dem automatisch generierten.