Mocking objecten in JUnit testen – best practice stack overflow

Denkt u dat het bespotten van objecten in JUnit test is een bests praktijk? Ik weet niet het grote voordeel te zien. Zeker als je een database die niet in de test is het zinvol moet worden beschouwd, maar waarom is niet alleen een andere uitvoering van die component geïnjecteerd (als het voorjaar wordt gebruikt). Een object in de fabriek voor de tests zou dit veel gemakkelijk te maken. Ik heb niet veel ervaring (wij gebruiken Mockito), maar ik heb al gezien, dat de toepassing code wordt gewijzigd, zodat bepaalde eigenschappen krijgt mockable! Test gevallen mag nooit Efford dergelijke veranderingen in productieve code in mijn advies.

Dus wat denk je van dit onderwerp? In welke gevallen hoeft u spottende uw object of waarom je dat niet doen?


gevraagd 4 mei ’11 op 08:52

Gesloten als niet constructief door Janak Nirmal. Ed Staub. Mac. Dominik Honnef. carlosfigueira 20 november ’12 om 23:54

In zijn huidige vorm, deze vraag is niet een goede pasvorm voor onze Q&A-formaat. We verwachten dat de antwoorden worden ondersteund door feiten, referenties, of deskundigheid, maar deze vraag zal waarschijnlijk vragen debat, argumenten, polling of uitgebreide discussie. Als u het gevoel dat deze vraag kan worden verbeterd en mogelijk heropend, bezoek de hulp centrum voor begeleiding. Indien deze vraag kan worden geherformuleerd om de regels passen in het helpcentrum. bewerkt u de vraag.

Ik heb al gezien, dat de toepassing code wordt gewijzigd, zodat bepaalde eigenschappen krijgt mockable! Test gevallen mag nooit Efford dergelijke veranderingen in productieve code in mijn advies.

De kerngedachte van TDD is dat door het dwingt je om al uw code toetsbaar te maken, het ontwerp in het algemeen beter te worden. Dit betekent niet noodzakelijk dat gewoon alles mockable hebben, het kan ook betekenen dat het verminderen van de koppeling, zodat er minder spottende noodzakelijk is.

Zelfs als u het niet eens met dat de filosofie (ik koop het niet 100% ikzelf), zolang je gelooft dat geautomatiseerde tests bieden waarde, dan is het veranderen van de productie code te steunen die waarde zinvol is (tenzij het ernstig afbreuk doet aan de ontwerp op een andere manier).

antwoordde 4 mei ’11 op 09:22

  • Definieert kalibreren klassen interfaces (interface ontdekking )
  • Hiermee boven naar beneden ontwerp
  • Isolatie (unit testing)
  • Verduidelijkt de interacties tussen klassen
  • Soms is de enige manier om te zien of object doet wat je wilt (Mocks and Tell Do not Ask)
  • Aangemoedigd beter gestructureerd testen. Bijvoorbeeld jukito auto-injecteert bespot om u in staat om zich te concentreren op de dingen u vertrouwen wilt testen.
  • Hiermee behoud inkapseling

Value object mag niet worden bespot

Spottende kaders groeien-out van de noodzaak. Zoals Matthew Gilliard gezegd, als er een soort van spot gaande is, dan is het teken dat het ontwerp kan worden verbeterd of het ontbreken van de test focus. Tests onthult veel problemen in de code.

maar waarom is niet alleen geïnjecteerd een andere uitvoering van dat onderdeel (als het voorjaar wordt gebruikt).

Je moet implementatie te schrijven. Met behulp van spottende kader wordt voor u gedaan.

Ik heb al gezien, dat de toepassing code wordt gewijzigd, zodat bepaalde eigenschappen krijgt mockable! Test gevallen mag nooit moeite dergelijke veranderingen in productieve code in mijn mening.

Als mockable middel testbaar dan is het andersom. Bijvoorbeeld, in TDD-test bepaalt productiecode.

Ik denk dat de echte vraag is of unit testing is een best practice of niet. Als je denkt dat het is, dan is het gebruik van spot is een noodzaak, vanuit het oogpunt van het hebben van een geteste eenheid geïsoleerd van de uitvoering van zijn afhankelijkheden.

Er is enige verwarring in hoe dit zich verhoudt tot het concept van de testbaarheid. though. Ingewikkeld, ingewikkelde code niet testbaar voornamelijk omdat het moeilijk te begrijpen. Goed ingecalculeerd code die heeft een schone en eenvoudig ontwerp is over het algemeen gemakkelijker te begrijpen en te onderhouden; waarom zou het moeilijk om unit test, dan?

De verwarring komt voort uit bepaalde willekeurige beperkingen gevonden in sommige bespotten instrumenten, zoals het onvermogen om definitieve of statische methoden bespotten, of de noodzaak om de geteste apparaat direct moeten gebruiken mock objecten die zijn gemaakt in de test code. Andere spottende gereedschap niet over deze beperkingen en dienen derhalve niet dat "applicatie code wordt gewijzigd, zodat bepaalde eigenschappen krijgen mockable". Met moderne programmeertalen / platforms (Java, C #, Python, Ruby, etc.) alles is mockable; het is gewoon een kwestie van deze bevoegdheid bloot in een spottende API, en het is al gedaan voor elk van die talen (in het belang van volledige openheid, ontwikkel ik een dergelijk instrument).

antwoordde 4 mei ’11 op 19:43

2017 Stack Exchange, Inc

Bron: stackoverflow.com

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

twee × 4 =