Kiedy powinienem pisać testy integracyjne?

Zgodnie z zasadami testów jednostkowych TDD są pisane przed kodem produkcyjnym, ale co z testami integracyjnymi, które ćwiczą interakcję między konkretnymi (nie udawanymi) obiektami przewodowymi?

Czy powinny być napisane przed testami jednostkowymi czy po kodzie produkcyjnym, aby przetestować „okablowanie”?

Pamiętaj, że nie mówię o testach akceptacyjnych ani funkcjonalnych, ale testach integracyjnych niższego poziomu.

Rspec Book , wśród innych zasobów BDD, sugeruje taki cykl:

Zasadniczo proces jest następujący:

While behaviour required
    Write an integration test for a specific behaviour
    While integration test failing
        Write a unit test to fulfil partial behavior
        While unit test failing
            Write code to make unit test pass
        Commit
        While refactoring can be done
            Refactor
            While unit test failing
                Write code to make unit test pass
            Commit
    Push

Oświadczenie: nie mam wątpliwości, że prowadzi to do najlepszego kodu i produktu, ale może być czasochłonne. Istnieją różne rodzaje trudności związanych z danymi i determinizmem, jeśli chodzi o stwierdzenie, że testy integracyjne powinny zawsze przejść pomyślnie. Nie jest właściwe we wszystkich okolicznościach; czasami trzeba po prostu wyciągnąć coś z drzwi.

To powiedziawszy, mając na uwadze idealny proces, jest świetny. Daje ci punkt do kompromisu.

Prawdziwy projekt pokazał mi, że nie jest możliwe napisanie testów jednostkowych, a następnie integracja, a nawet odwrotny kierunek jest niewłaściwy :-) Tak więc zwykle piszę testy jednostkowe razem z testami integracyjnymi.

Czemu? Pozwól mi napisać, jak widzę oba rodzaje testów:

1. Testy jednostkowe - Oprócz Wikipedii i wszystkich znanych informacji, testy jednostkowe pomagają zawęzić projekt , ulepszyć model, relacje. Przebieg jest prosty: kiedy zaczniesz pisać nowy projekt / nowy komponent, przez większość czasu tworzysz jakiś rodzaj PoC . Kiedy skończysz, zawsze masz długie metody, długie klasy, niespójne metody i klasy itp.

   Testy jednostkowe pomagają usunąć te problemy, ponieważ podczas przeprowadzania rzeczywistych testów jednostkowych przy użyciu próbnych (bez zależności od innych komponentów) klas opisanych powyżej nie można przetestować. Podstawowym znakiem niestabilnego kodu jest duża część kpiąca testów, ponieważ jesteś zmuszony kpić z wielu zależności (lub sytuacji)

2. Testy integracyjne - testy poprawne i robocze mówią ci, że twój nowy komponent (lub komponenty) współpracują razem lub z innymi komponentami - jest to zwykle definicja. Przekonałem się, że testy integracyjne w większości pomagają zdefiniować sposób korzystania z komponentu od strony konsumenta .

   Jest to naprawdę ważne, ponieważ czasami mówi ci, że Twój interfejs API nie ma sensu z zewnątrz.

Co się stanie, gdy później napisze testy jednostkowe i testy integracyjne?

Dostałem fajne klasy, przejrzysty projekt, dobry konstruktor, krótkie i spójne metody, gotowy na IoC itp. Gdy podałem moją klasę / interfejs API niektórym konsumentom, np. Programistom z zespołu ds. Integracji lub GUI, nie był w stanie używać mojego API, ponieważ wydaje się to nielogiczne , dziwne. Po prostu był zdezorientowany. Naprawiłem API zgodnie z jego punktem widzenia, ale wymagało to również przepisania wielu testów, ponieważ zmuszono mnie do zmiany metod, a czasem nawet do sposobu korzystania z API.

Co się stanie, gdy później napisałem testy integracyjne i testy jednostkowe?

Mam dokładny przepływ, dobrą użyteczność. Mam też duże klasy, niespójny kod, brak rejestrowania, długie metody. Kod spaghetti

Jaka jest moja rada

Nauczyłem się następującego przepływu:

1. Opracuj podstawowy szkielet swojego kodu
2. Napisz testy integracyjne, które stwierdzą, czy ma to sens z punktu widzenia konsumenta. Na razie wystarczy podstawowy przypadek użycia. Test oczywiście nie działa.
3. Napisz kod wraz z testami jednostkowymi dla każdej klasy.
4. Napisz resztę / brak testów integracji. Lepiej byłoby zaimplementować te testy w ramach # 3, w jaki sposób poprawiasz swój kod.

Zauważ, że zrobiłem małą prezentację na temat testowania jednostek / integracji, patrz slajd nr 21, w którym opisano szkielet.

Testy jednostkowe służą do testowania najmniejszego możliwego do przetestowania bitu oprogramowania w aplikacji i testowania jego funkcjonalności. Każda jednostka jest testowana osobno przed połączeniem ich w części lub większe elementy aplikacji.

W tym momencie pojawiają się testy integracji :
testują te nowo utworzone części, które składają się z wcześniej przetestowanych jednostek podczas montażu tych części razem. Najlepszym rozwiązaniem byłoby napisanie testów w tym momencie podczas pisania samej aplikacji.

Testy integracji postrzegam jako bardzo podobne do testów jednostkowych. Pod tym względem traktuję podzbiór kodu jako czarną skrzynkę. Testy integracyjne są więc po prostu większym pudełkiem.

Wolę pisać je przed kodem produkcyjnym. Ma to tę zaletę, że pomaga mi zapamiętać, które elementy jeszcze nie podłączyłem lub że zmieniłem nieco szczegóły interakcji obiektów.

Oprócz testów akceptacyjnych staram się pisać testy integracyjne tylko na granicach aplikacji, aby sprawdzić, czy dobrze integruje się z systemami lub komponentami innych firm.

Chodzi o to, aby utworzyć obiekty adaptera, które tłumaczą sposób, w jaki firma zewnętrzna mówi do tego, czego potrzebuje twoja aplikacja, i przetestuj tych translatorów na prawdziwym systemie zewnętrznym. Niezależnie od tego, czy wykonujesz ten test jako pierwszy, czy testowy, myślę, że jest mniej ważne niż w przypadku regularnych testów jednostkowych, ponieważ

• Wgląd w projekt zapewniony przez TDD nie ma tutaj tak wielkiego znaczenia, ponieważ projekt jest dość dobrze znany z góry i zwykle nie ma w tym nic strasznie skomplikowanego, po prostu mapujesz rzeczy z jednego systemu do drugiego.

• W zależności od modułu / systemu, którym chcesz się zająć, może to wymagać dużo eksploracji, majsterkowania konfiguracji, przygotowania danych próbek, co zajmuje dużo czasu i nie pasuje zbyt dobrze w krótkiej pętli sprzężenia zwrotnego TDD.

Jeśli jednak naprawdę czujesz się bardziej komfortowo, budując swój adapter stopniowo w małych, bezpiecznych krokach, zdecydowanie polecam przetestowanie go jako pierwszego, to nie zaszkodzi.

Przykłady tego podejścia można znaleźć tutaj: http://davesquared.net/2011/04/dont-mock-types-you-dont-own.html (6. akapit) http://blog.8thlight.com/eric- smith / 2011/10/27 / thats-not-yours.html

Zamierzałem więc przyjąć pierwszą odpowiedź, ale została ona usunięta.
Podsumowując
w danej iteracji:

1. Napisz test jednostkowy
2. Napisz kod produkcyjny
3. Napisz testy integracji, aby przetestować interakcje

Należy pamiętać o testach integracyjnych 1 i 2, aby zagwarantować testowalność na poziomie integracji.

Testy integracyjne niekoniecznie są pisane od końca do końca w kroku 3, mogą być częściowo zapisane między krokami 1 i 2.

Testy jednostkowe testują dyskretne bloki kodu w projekcie.
Testy integracyjne sprawdzają, w jaki sposób twój kod łączy się z innym kodem: innymi słowy, testują interfejs twojego kodu.

Napisz testy jednostkowe podczas opracowywania kodu za interfejsem.
Napisz testy integracji podczas opracowywania interfejsu lub dowolnego kodu implementującego interfejs.

Oznacza to, że czasem testy integracyjne będą pisane bardzo późno w projekcie, ponieważ większość pracy znajduje się za interfejsem: na przykład kompilator, konkretna usługa internetowa, która implementuje kilka warstw logiki lub ... coś, co wymaga dużej ilości logika wewnętrzna.

Jeśli jednak wdrażasz zestaw usług REST lub refaktoryzujesz model danych i dodajesz obsługę transakcji XA, prawie natychmiast zaczniesz opracowywać testy integracyjne, ponieważ większość pracy koncentruje się wokół interfejsu, niezależnie od tego, czy jest to interfejs interfejs API REST lub sposób, w jaki program korzysta z modelu danych.