Simulieren Sie eine Methode zum test

Sollte dies funktionieren, vorausgesetzt, diese sind die vollständige Methode Implementierungen

public class MyProgram
{

    public bool hello(string name, int age)
    {
        string lastName = GetLastName();

        return string.Format("hello {0}", lastName);
    }

    public virtual string GetLastName() 
    {
        return "xxx"; 
    }
}

public class MyProgramTests
{

    [TestMethod]
    public void MyTest()
    {

        string stringToReturn = "qqq";
        Mock<MyProgram> name = new Mock<MyProgram>();
        name.CallBase = true;
        name.Setup(x => x.GetLastName()).Returns(stringToReturn );

        var results = name.Object.hello(It.IsAny<string>(), It.IsAny<int>());

        string expected = string.Format("hello {0}", results);

        Assert.AreEqual(expected, results);
    }
}

Bin ich noch nicht ganz, nach deinem Kommentar:

Was bedeutet der parameter eigentlich bedeuten von Mock Was soll das ?? werden? entschuldigen Sie mich, ich verstehe nicht ganz die syntax. Um zu klären, mock bedeutet, dass, wenn ich Pause Punkte in meinem code habe ich die Haltepunkte sollten überspringen Sie die Methoden, die ich spöttisch. Bin ich im Recht?

Mock<T> können Sie zu verspotten, eine Art von T - T wird eine generische Anzeige, die auch Sinn so ziemlich alles, was ein Klasse. In der traditionellen, Sie wäre Spott ein interface, nicht eine tatsächliche class, aber in dem Beispiel oben, wir sind die Verspottung der a-Klasse. Für den Beispiel-unit-test geschrieben, der Zweck der unit test testen Sie die Implementierung von hello(string, int). Wir wissen, dass hello(string, int) beruht auf einer anderen Methode innerhalb dieser Klasse aufgerufen GetLastName(). GetLastName()s Umsetzung, wenn auch wichtig, nicht wichtig ist, um den Umfang von unit-Tests hello(string, int). Aus diesem Grund, wir verspotten den Anruf und seiner Rückkehr - zum testen der Funktionalität von hello(string, int) ohne sich sorgen über Ihre Abhängigkeit Implementierung.

Ich habe umgeben, die oben mit dem eigentlichen Klassennamen, um hoffentlich deutlicher machen, dass wir Spott der Klasse MyProgram und bietet eine neue Implementierung (mock) GetLastName()

Danke für die Antwort. Was ist, wenn ich testen will, eine Methode ruft eine andere Methode ruft eine andere Methode? Für zB. was ist, wenn die Methode hello rief eine andere Methode?

Das gleiche Prinzip gilt, wenn Sie bauen Ihre unit-tests (vorausgesetzt, Sie sind Einheit tests, und nicht die integration-tests oder andere, Sie wollen immer konzentrieren sich auf Tests, die eine öffentliche Methode. Was ist der Unterschied zwischen unit-und integration tests?

public class Foo
{

    public string Bar()
    {
        return string.Format("{0}Bar", Baz(5));;
    }

    public virtual string Baz(int someNumber)
    {
        return string.Format("{0}Baz", DoStuff(someNumber).ToString());
    }

    public virtual int DoStuff(int someNumber)
    {
        return someNumber+1;
    }

}

Wenn wir unit-Tests Bar() wir kümmern uns nicht um die Umsetzung von Baz(int) oder noch schlimmer DoStuff(int). Hinweis wir kümmern uns nicht um die Umsetzung, wir tun darauf, dass Sie die Werte zurückgeben. Von Bar()s Sicht, die einzige Sache, die wichtig ist, ist die Baz(int) gibt einen string zurück. Was für Schnur? Es spielt keine Rolle, zu Bar()s Einheit test.

Probe-test für Bar():

[TestMethod]
public void Bar_ReturnsBazValueWithBarAppended
{
    //Arrange
    string testBazReturn = "test";
    Mock<Foo> mock = new Mock<Foo>();
    mock.CallBase = true;
    mock
        .Setup(s => s.Baz(It.IsAny<int>())
        .Returns(testBazReturn);

    //Act
    var results = mock.Object.Bar();

    //Assert
    Assert.AreEqual(string.Format("{0}{1}", testBazReturn, "Bar"), results);
    mock.Verify(v => v.Baz(It.IsAny<int>())); //Verifies that Baz was called
}

Beachten Sie in der oben, unsere aktuelle Implementierungen von Baz(int), und DoStuff(int) nicht egal, wie wir sind, ohne auf die tatsächliche Umsetzung von Baz(int), und DoStuff(int) gar nicht ins Spiel kommen.

Nun, wenn wir testen Baz(int) Folgen wir einfach die gleiche Mentalität:

[TestMethod]
public void Baz_ReturnsDoStuffValueWithBazAppended
{
    //Arrange
    int testDoStuffReturn = 1;
    Mock<Foo> mock = new Mock<Foo>();
    mock.CallBase = true;
    mock
        .Setup(s => s.DoStuff(It.IsAny<int>())
        .Returns(testDoStuffReturn);

    //Act
    var results = mock.Object.Baz(5);

    //Assert
    Assert.AreEqual(string.Format("{0}{1}", results, "Baz"), results); //Validates the result
    mock.Verify(v => v.DoStuff(It.IsAny<int>())); //Verifies that DoStuff was called
}

In der oben, jetzt sind wir unit-Tests Baz(int), wir kümmern uns nicht um Bar(), und das einzige, was wir über Pflege in DoStuff(int) ist, dass es einen Wert zurückgibt (aber nicht wie es kommt an diesen Wert.)

Und schließlich DoStuff(int):

[TestMethod]
public void DoStuff_ReturnsParameterPlusOne()
{
    //Arrange
    Foo foo = new Foo();
    int passed = 1;
    int expected = passed + 1;

    //Act
    var results = foo.DoStuff(passed);

    //Assert
    Assert.AreEqual(expected, results);
}

InformationsquelleAutor Kritner