Hoe kan ik JUnit-testafhankelijkheden specificeren?

Onze toolkit heeft meer dan 15000 JUnit-tests, en van veel tests is bekend dat ze mislukken als een andere test mislukt. Als de methode X.foo() bijvoorbeeld functionaliteit van Y.bar() en YTest.testBar() gebruikt, mislukt, dan zal XTest.testFoo() ook mislukken. Uiteraard kan XTest.testFoo() ook mislukken vanwege problemen die specifiek zijn voor X.foo().

Hoewel dit prima is en ik wil nog steeds dat beide tests worden uitgevoerd, zou het fijn zijn als men een testafhankelijkheid zou kunnen annoteren met XTest.testFoo() wijzend naar YTest.testBar(). Op deze manier kon men meteen zien welke functionaliteit die door X.foo() wordt gebruikt ook faalt, en welke niet.

Is er een dergelijke annotatie beschikbaar in JUnit of elders? Iets als:

public XTest {
  @Test
  @DependsOn(method=org.example.tests.YTest#testBar)
  public void testFoo() {
     // Assert.something();
  }
}

Antwoord 1, autoriteit 100%

JEVoorbeelden TestNGhebben zoiets.

Ik weet niet hoe nuttig het is, maar als je het probeert, kom dan alsjeblieft terug om ons te vertellen of het nuttig was.

Antwoord 2, autoriteit 76%

Er is een bijdrage aan JUnit die hierop ingaat: https://github.com/junit- team/junit.contrib/tree/master/assumes

Antwoord 3, autoriteit 28%

org.junit.FixMethodOrder

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
Dit komt bovenop je Unit-testklasse.

U kunt uw methoden een naam geven public void step1_methodName etc

Antwoord 4, autoriteit 16%

U kunt testafhankelijkheden declareren in TestNG, de syntaxis is bijna hetzelfde als in uw voorbeeld. Ik denk niet dat JUnit iets soortgelijks aanbiedt.

Antwoord 5, autoriteit 4%

In gedragsgestuurd ontwerpbibliotheek jGedraag jeer is een trefwoord GivenScenariosdat een lijst met scenario’s importeert die worden uitgevoerd vóór het hoofdscenario. Dit geeft de mogelijkheid om afhankelijkheden te definiëren en één storingspunt te hebben. De logboekregistratie van jBehave zal u vertellen of de test mislukt in afhankelijkheden of in het hoofdgedeelte.

Antwoord 6, autoriteit 4%

Ik ken zoiets echt niet.(Edit: je leert elke dag iets nieuws :)) Naar mijn mening is dit niet zo’n slechte zaak (hoewel ik kan zien dat het nuttig is, vooral wanneer JUnit het wordt gebruikt voor andere vormen van geautomatiseerde tests – bijvoorbeeld integratietests). Je tests, IMO, zijn niet in de strikte zin van het woord “eenheidstests” (tenminste niet de test voor X#foo()). Tests voor X#foo()zouden moeten slagen of mislukken, afhankelijk van alleenvan de implementatie van X#foo(). Het mag niet afhankelijk zijn van Y#foo().

Wat ik in jouw positie zou doen, is Y belachelijk maken en iets als MockY#foo()implementeren met heel eenvoudig, gecontroleerd gedrag, en het gebruiken in X#foo()‘s tests.

Dat gezegd hebbende, met 15.000 tests, kan ik zien dat dit lastig zou zijn om te refactoren. 🙂