Einen Test auf eine Reihe kleinerer Tests aufteilen

Question

Ich möchte einen großen Test auf kleinere Tests aufteilen, so dass, wenn die kleineren Tests bestanden haben, sie auch bedeuten, dass der große Test bestanden wird (also gibt es keinen Grund, das zu testen) ursprünglicher großer Test). Ich möchte dies tun, weil kleinere Tests normalerweise weniger Zeit, weniger Aufwand und weniger anfällig sind. Ich würde gerne wissen, ob es Testdesignmuster oder Verifikationswerkzeuge gibt, die mir helfen können, diese Testspaltung auf eine robuste Art und Weise zu erreichen.

Ich befürchte, dass die Verbindung zwischen den kleineren Tests und dem ursprünglichen Test verloren geht, wenn jemand etwas in den kleineren Tests ändert. Eine weitere Befürchtung ist, dass der Satz kleinerer Tests den großen Test nicht wirklich abdeckt.

Ein Beispiel dessen, was ich bin mit dem Ziel:

//Class under test 
class A { 

    public void setB(B b){ this.b = b; } 

    public Output process(Input i){ 
    return b.process(doMyProcessing(i)); 
    } 

    private InputFromA doMyProcessing(Input i){ .. } 

    .. 

} 

//Another class under test 
class B { 

    public Output process(InputFromA i){ .. } 

    .. 

} 

//The Big Test 
@Test 
public void theBigTest(){ 
A systemUnderTest = createSystemUnderTest(); // <-- expect that this is expensive 

Input i = createInput(); 

Output o = systemUnderTest.process(i); // <-- .. or expect that this is expensive 

assertEquals(o, expectedOutput()); 
} 

//The splitted tests 

@PartlyDefines("theBigTest") // <-- so something like this should come from the tool.. 
@Test 
public void smallerTest1(){ 
    // this method is a bit too long but its just an example.. 
    Input i = createInput(); 
    InputFromA x = expectedInputFromA(); // this should be the same in both tests and it should be ensured somehow 
    Output expected = expectedOutput(); // this should be the same in both tests and it should be ensured somehow 

    B b = mock(B.class); 
    when(b.process(x)).thenReturn(expected); 

    A classUnderTest = createInstanceOfClassA(); 
    classUnderTest.setB(b); 

    Output o = classUnderTest.process(i); 

    assertEquals(o, expected); 
    verify(b).process(x); 
    verifyNoMoreInteractions(b); 
} 

@PartlyDefines("theBigTest") // <-- so something like this should come from the tool.. 
@Test 
public void smallerTest2(){ 
    InputFromA x = expectedInputFromA(); // this should be the same in both tests and it should be ensured somehow 
    Output expected = expectedOutput(); // this should be the same in both tests and it should be ensured somehow 

    B classUnderTest = createInstanceOfClassB(); 

    Output o = classUnderTest.process(x); 

    assertEquals(o, expected); 
} 

Answer 1

Der erste Vorschlag, den ich machen werde, besteht darin, Ihre Tests auf Rot (failing) zu re-Faktor. Um dies zu tun, müssen Sie Ihren Produktionscode vorübergehend unterbrechen. Auf diese Weise wissen Sie, dass die Tests noch gültig sind.

Ein übliches Muster ist die Verwendung einer separaten Testvorrichtung für jede Sammlung von "großen" Tests. Sie müssen sich nicht an das Muster "alle Tests für eine Klasse in einer Testklasse" halten. Wenn eine Reihe von Tests miteinander in Beziehung stehen, aber nicht mit einer anderen Gruppe von Tests in Beziehung stehen, dann legen Sie sie in ihre eigene Klasse.

Der größte Vorteil bei der Verwendung einer separaten Klasse für die einzelnen kleinen Tests für den großen Test besteht darin, dass Sie die Vorteile von Setup- und Abnutzungsmethoden nutzen können. In Ihrem Fall würde ich die Linien bewegen Sie kommentiert haben:

// this should be the same in both tests and it should be ensured somehow

auf die Setup-Methode (in JUnit, ein Verfahren mit @Before kommentierten). Wenn Sie ein ungewöhnlich kostspieliges Setup haben, das erledigt werden muss, haben die meisten xUnit-Testframeworks eine Möglichkeit, eine Setup-Methode zu definieren, die vor allen Tests einmal ausgeführt wird. In JUnit ist dies eine public static void-Methode, die die @BeforeClass Annotation hat.

Wenn die Testdaten unveränderlich sind, tendiere ich dazu, die Variablen als Konstanten zu definieren.

alles Putting zusammen, man könnte so etwas wie haben:

public class TheBigTest { 

    // If InputFromA is immutable, it could be declared as a constant 
    private InputFromA x; 
    // If Output is immutable, it could be declared as a constant 
    private Output expected; 

    // You could use 
    // @BeforeClass public static void setupExpectations() 
    // instead if it is very expensive to setup the data 
    @Before 
    public void setUpExpectations() throws Exception { 
     x = expectedInputFromA(); 
     expected = expectedOutput(); 
    } 

    @Test 
    public void smallerTest1(){ 
     // this method is a bit too long but its just an example.. 
     Input i = createInput(); 

     B b = mock(B.class); 
     when(b.process(x)).thenReturn(expected); 

     A classUnderTest = createInstanceOfClassA(); 
     classUnderTest.setB(b); 

     Output o = classUnderTest.process(i); 

     assertEquals(o, expected); 
     verify(b).process(x); 
     verifyNoMoreInteractions(b); 
    } 

    @Test 
    public void smallerTest2(){ 
     B classUnderTest = createInstanceOfClassB(); 

     Output o = classUnderTest.process(x); 

     assertEquals(o, expected); 
    } 

} 

Answer 2

Alles, was ich kann, ist das Buch vorschlagen xUnit Test Patterns. Wenn es eine Lösung gibt, sollte es da drin sein.

Answer 3

theBigTest ist die Abhängigkeit von B fehlt. Auch smallerTest1 Mocks B Abhängigkeit. In smallerTest2 sollten Sie InputFromA spotten.

Warum haben Sie einen Abhängigkeitsgraphen wie Sie erstellt?

A nimmt ein B dann, wenn A::processInput Sie dann Prozess schreiben InputFromA in B.

Behalten Sie den großen Test und Refactor A und B, um die Abhängigkeitszuordnung zu ändern.

[EDIT] als Reaktion auf Bemerkungen.

@mkorpela, ist mein Punkt, dass auf den Code und deren Abhängigkeiten von der Suche ist, wie Sie eine Vorstellung davon, wie man beginnen kleinere Tests zu erstellen. A hat eine Abhängigkeit von B. Um die process() zu vervollständigen, muss Bprocess() verwendet werden. Aus diesem Grund hat B eine Abhängigkeit von A.