Początek TDD-wyzwania? Rozwiązania? Zalecenia? [zamknięte]

Z własnego doświadczenia:

1. Przetestuj tylko swój własny kod, a nie kod bazowego frameworka. Więc jeśli używasz listy generycznej, nie ma potrzeby testowania dodawania, usuwania itp.

2. Nie ma 2. Spójrz tam! Małpy!!!

3. NUnit jest drogą do zrobienia.

4. Na pewno nie możesz sprawdzić każdego wyniku. Testuję to, czego oczekuję, a następnie testuję kilka skrajnych przypadków, w których oczekuję wyjątków lub nieprawidłowych odpowiedzi. Jeśli błąd pojawi się na ścieżce z powodu czegoś, co zapomniałeś przetestować, pierwszą rzeczą, którą powinieneś zrobić (zanim spróbujesz naprawić błąd), jest napisanie testu, aby udowodnić, że błąd istnieje.

Moje zdanie na ten temat jest następujące:

• + 1 dla nie testowania kodu framework, ale nadal może być konieczne przetestowanie klas wywodzących się z framework classes.
• jeśli jakaś Klasa/metoda jest uciążliwa do testowania, może to być silne wskazanie, że coś jest nie tak z desingiem. Staram się przestrzegać zasady "1 klasa - 1 odpowiedzialność, 1 Metoda - 1 działanie". W ten sposób będziesz mógł testować złożone metody znacznie łatwiej, robiąc to w mniejszych porcjach.
• + 1 dla xUnit. Dla Javy możesz również rozważmy TestNG .
• TDD nie jest pojedynczym zdarzeniem, jest procesem. Więc nie próbuj wyobrażać sobie wszystkiego od początku, ale upewnij się, że każdy błąd znaleziony w kodzie jest rzeczywiście objęty testem po wykryciu.

Myślę, że najważniejszą rzeczą z (a właściwie jednym z wielkich wyników, w nieco rekurencyjny sposób) TDD jest skuteczne zarządzanie zależnościami. Musisz upewnić się, że moduły są testowane w izolacji bez skomplikowanej konfiguracji. Na przykład, jeśli testujesz komponent, który ostatecznie wysyła wiadomość e-mail, Ustaw nadawcę wiadomości e-mail jako zależność, aby można było z niej korzystać w testach. To prowadzi do drugiego punktu-kpiny są twoimi przyjaciółmi. Zapoznaj się z wyśmiewaniem frameworki i styl testów, które promują (behawioralne, w przeciwieństwie do klasycznych opartych na stanie), oraz wybory projektowe, które zachęcają (zasada "Powiedz, nie pytaj").

Odkryłem, że zasady przedstawione w trzech kart indeksowych, aby łatwo zapamiętać istotę TDD jest dobrym przewodnikiem.

Anyway, to answer your questions

1. nie musisz testować czegoś, co "wiesz", że zadziała, chyba że to napisałeś. Nie napisałeś generyków, tylko Microsoft;)
2. Jeśli musisz zrobić tak wiele dla swojego testu, być może twój obiekt / metoda robi zbyt wiele, jak również.
3. Pobierz TestDriven.NET aby natychmiast uruchomić jednostkę testowanie na Twoim Visual Studio (chyba, że jest to edycja Express)
4. po prostu przetestuj poprawną rzecz, która się wydarzy. Nie potrzebujesz , aby przetestować wszystko, co może pójść źle: musisz czekać, aż testy się nie powiedzą.

Poważnie, po prostu to zrób, koleś. :)

W żadnym wypadku nie jestem ekspertem w TDD, ale oto mój pogląd:

• jeśli jest całkowicie trywialny (getters/setters itp.), nie testuj go, chyba że z jakiegoś powodu nie masz zaufania do kodu.
Jeśli jest to dość prosta, ale nietrywialna metoda, przetestuj ją. Test pewnie i tak jest łatwy do napisania.
• Jeśli chodzi o to, czego się spodziewać, że się nie stanie, powiedziałbym, że jeśli pewnym potencjalnym problemem jest odpowiedzialność klasy, którą testujesz, musisz przetestować że obsługuje to poprawnie. Jeśli nie odpowiada za to obecna klasa, nie testuj jej.

Frameworki testowe xUnit są często bezpłatne, więc jeśli jesteś facetem z. Net, sprawdź NUnit, a jeśli lubisz Javę, sprawdź JUnit.

Powyższa rada jest dobra, a jeśli chcesz mieć listę darmowych frameworków, nie musisz szukać dalej niż Lista frameworków xUnit Na Wikipedii. Mam nadzieję, że to pomoże:)

Moim zdaniem (przebieg może się różnić):

1-Jak nie napisałeś to nie testuj. Jeśli go napisałeś i nie masz do niego testu to nie istnieje.

3 - Jak wszyscy mówili, xUnit jest wolny i świetny.

2 & 4-decydowanie o tym, co dokładnie przetestować, jest jedną z tych rzeczy, o których możesz dyskutować ze sobą na zawsze. Staram się kreślić tę linię stosując zasady projektowania przez umowę. Sprawdź 'obiektowa Budowa oprogramowania' lub 'pragmatyczny programista' po szczegóły robi się.

Trzymaj testy krótko, "atomowe". Przetestuj najmniejsze założenie w każdym teście. Zrób każdy Testmetod niezależny, dla testów integracyjnych nawet utworzyć nową bazę danych dla każdej metody. Jeśli potrzebujesz zbudować dane dla każdego testu, użyj metody "Init". Użyj mocks, aby oddzielić klasę testowaną od jej zależności.

Zawsze myślę "jaka jest minimalna ilość kodu, którą muszę napisać, aby udowodnić, że to działa we wszystkich przypadkach ?"

W ciągu ostatniego roku stałem się coraz bardziej przekonany o korzyściach płynących z TDD. Rzeczy, których nauczyłem się po drodze: 1) dependency injection jest twoim przyjacielem. Nie mówię o inwersji kontenerów sterujących i frameworków do montowania architektur wtyczek, tylko o przekazaniu zależności do konstruktora testowanego obiektu. To zwraca ogromne dywidendy w testowalności kodu. 2) wyruszyłem z pasją / gorliwością nawróconego i chwyciłem szyderczego framework i zestaw o używaniu mocks do wszystkiego, co mogłem. Doprowadziło to do kruchych testów, które wymagały wielu bolesnych ustawień i przewróciłyby się, gdy tylko zacząłem refaktoryzację. Użyj odpowiedniego rodzaju podwójnego testu. Podróbki, w których musisz tylko honorować interfejs, stuby do przekazywania danych z powrotem do testowanego obiektu, makiety tylko tam, gdzie zależy ci na interakcji. 3) Test powinien być mały. Celuj w jedno twierdzenie lub interakcję badaną w każdym teście. Staram się to robić i przeważnie tam jestem. To jest o solidności kodu testowego, a także o złożoności testu, gdy trzeba go później ponownie odwiedzić.

Największym problemem, jaki miałem z TDD, była praca ze specyfikacją z organu normalizacyjnego i implementacja przez stronę trzecią tego standardu, który był de facto standardem. Zakodowałem wiele naprawdę ładnych testów jednostkowych zgodnie z literą specyfikacji tylko po to, aby stwierdzić, że implementacja po drugiej stronie ogrodzenia postrzegała standard jako bardziej doradczy dokument. Grali z tym dość luźno. Jedynym sposobem, aby to naprawić, było przetestowanie z implementacją, jak również testy jednostkowe i refakturowanie testów i kodu w razie potrzeby. Prawdziwym problemem było przekonanie z mojej strony, że tak długo, jak miałem kod i testy jednostkowe wszystko było dobre. Nie. Musisz budować rzeczywiste wyniki i przeprowadzać testy funkcjonalne w tym samym czasie, co testy jednostkowe. Małe korzyści przez cały proces-w ręce użytkowników lub interesariuszy.

Jako dodatek do tego, pomyślałem, że powiem, że umieściłem blog post na moich przemyśleniach na temat rozpoczęcia testów( po tej dyskusji i moich własnych badaniach), ponieważ może to być przydatne dla osób oglądających ten wątek.

"TDD-pierwsze kroki z rozwojem opartym na testach " - otrzymałem jak dotąd świetne opinie i byłbym wdzięczny za więcej, które macie do zaoferowania.

Mam nadzieję, że to pomoże! :)