Gdzie przebiega granica między logiką aplikacji do testowania jednostkowego a konstrukcjami nieufnymi językami?

Rozważ taką funkcję:

function savePeople(dataStore, people) {
    people.forEach(person => dataStore.savePerson(person));
}

Można go użyć w następujący sposób:

myDataStore = new Store('some connection string', 'password');
myPeople = ['Joe', 'Maggie', 'John'];
savePeople(myDataStore, myPeople);

Pozwól nam zakładać, że Storema swoje własne testy jednostkowe, czy sprzedawca-warunkiem. W każdym razie ufamy Store. Załóżmy ponadto, że obsługa błędów - np. Błędów rozłączenia bazy danych - nie jest odpowiedzialna za savePeople. Rzeczywiście, załóżmy, że sam sklep jest magiczną bazą danych, która nie może w żaden sposób popełnić błędu. Biorąc pod uwagę te założenia, pytanie brzmi:

Czy powinny savePeople()być testowane jednostkowo, czy też takie testy mogłyby oznaczać testowanie wbudowanej forEachkonstrukcji języka?

Moglibyśmy oczywiście wprowadzić próbną kpinę dataStorei zapewnić, że dataStore.savePerson()wezwanie jest raz dla każdej osoby. Z pewnością można argumentować, że taki test zapewnia bezpieczeństwo przed zmianami implementacyjnymi: np. Jeśli zdecydujemy się zastąpić forEachtradycyjną forpętlą lub inną metodą iteracji. Test nie jest więc całkowicie trywialny. A jednak wydaje się okropnie blisko ...

Oto kolejny przykład, który może być bardziej owocny. Zastanów się nad funkcją, która jedynie koordynuje inne obiekty lub funkcje. Na przykład:

function bakeCookies(dough, pan, oven) {
    panWithRawCookies = pan.add(dough);
    oven.addPan(panWithRawCookies);
    oven.bakeCookies();
    oven.removePan();
}

Jak taką funkcję należy testować jednostkowo, zakładając, że tak powinno być? Trudno mi sobie wyobrazić, wszelkiego rodzaju testów jednostkowych, które nie tylko Mock dough, pani oven, a następnie stwierdzić, że metody są wywoływane na nich. Ale taki test nie robi nic więcej, jak powielenie dokładnej implementacji funkcji.

Czy ta niezdolność do przetestowania funkcji w sensowny czarny sposób wskazuje na wadę projektową samej funkcji? Jeśli tak, jak można to poprawić?

Aby jeszcze bardziej wyjaśnić pytanie motywujące ten bakeCookiesprzykład, dodam bardziej realistyczny scenariusz, z którym się spotkałem przy próbie dodania testów i refaktoryzacji starszego kodu.

Gdy użytkownik utworzy nowe konto, musi się zdarzyć kilka rzeczy: 1) należy utworzyć nowy rekord użytkownika w bazie danych 2) należy wysłać powitalny e-mail 3) adres IP użytkownika musi zostać zarejestrowany w celu oszustwa cele.

Chcemy więc stworzyć metodę, która łączy wszystkie kroki „nowego użytkownika”:

function createNewUser(validatedUserData, emailService, dataStore) {
  userId = dataStore.insertUserRecord(validateduserData);
  emailService.sendWelcomeEmail(validatedUserData);
  dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Zauważ, że jeśli którakolwiek z tych metod zgłosi błąd, chcemy, aby błąd pojawił się w kodzie wywołującym, aby mógł obsłużyć błąd według własnego uznania. Jeśli jest wywoływany przez kod API, może przełożyć błąd na odpowiedni kod odpowiedzi http. Jeśli jest wywoływany przez interfejs sieciowy, może przełożyć błąd na odpowiedni komunikat wyświetlany użytkownikowi i tak dalej. Chodzi o to, że ta funkcja nie wie, jak obsłużyć błędy, które mogą zostać zgłoszone.

Istotą mojego pomieszania jest to, że do testowania jednostkowego takiej funkcji wydaje się konieczne powtórzenie dokładnej implementacji w samym teście (przez określenie, że metody są wywoływane na próbach w określonej kolejności) i to wydaje się nieprawidłowe.

Czy savePeople()należy przetestować jednostkę? Tak. Nie testujesz, czy dataStore.savePersondziała, czy działa połączenie db, a nawet czy foreachdziała. Testujesz, który savePeoplespełnia obietnicę, jaką daje dzięki umowie.

Wyobraź sobie ten scenariusz: ktoś dokonuje dużego refaktoryzacji bazy kodu i przypadkowo usuwa forEachczęść implementacji, aby zawsze zapisywał tylko pierwszy element. Czy nie chciałbyś, aby test jednostkowy to wykrył?

Zazwyczaj tego rodzaju pytanie pojawia się, gdy ludzie robią programowanie „po testach”. Podejdź do tego problemu z punktu widzenia TDD, gdzie testy poprzedzają implementację, i zadaj sobie to pytanie ponownie jako ćwiczenie.

Przynajmniej w mojej aplikacji TDD, która zwykle jest na zewnątrz, nie implementowałbym funkcji takiej jak savePeoplepo jej wdrożeniu savePerson. Funkcje savePeoplei savePersonbyłyby uruchamiane jako jedna i byłyby sterowane testami z tych samych testów jednostkowych; rozdzielenie między nimi nastąpiłoby po kilku testach na etapie refaktoryzacji. Ten tryb pracy postawiłby również pytanie, gdzie savePeoplepowinna być funkcja - czy jest to funkcja wolna, czy jej część dataStore.

W końcu, testy nie tylko sprawdzić, czy można poprawnie zapisać Personw Store, ale także wiele osób. Doprowadziłoby mnie to również do pytania, czy konieczne są inne kontrole, na przykład: „Czy muszę się upewnić, że savePeoplefunkcja jest atomowa, albo zapisuje wszystko, albo nie ma żadnej?”, „Czy może po prostu zwrócić błędy osobom, które nie mogły” zostać zapisane? Jak wyglądałyby te błędy? ”itd. Wszystko to oznacza znacznie więcej niż tylko sprawdzenie użycia jednej forEachlub innych form iteracji.

Chociaż, jeśli wymóg zapisania więcej niż jednej osoby naraz pojawił się dopiero po tym, jak savePersonzostał już spełniony , zaktualizowałbym istniejące testy, savePersonaby przejść przez nową funkcję savePeople, upewniając się, że nadal może uratować jedną osobę, po prostu delegując na początku, następnie przetestuj zachowanie więcej niż jednej osoby za pomocą nowych testów, zastanawiając się, czy konieczne byłoby nadanie temu atomowi charakteru, czy nie.

Należy zapisać savePeople () w testach jednostkowych

Tak, powinno. Ale spróbuj napisać warunki testowe w sposób niezależny od implementacji. Na przykład przekształcając przykład użycia w test jednostkowy:

function testSavePeople() {
    myDataStore = new Store('some connection string', 'password');
    myPeople = ['Joe', 'Maggie', 'John'];
    savePeople(myDataStore, myPeople);
    assert(myDataStore.containsPerson('Joe'));
    assert(myDataStore.containsPerson('Maggie'));
    assert(myDataStore.containsPerson('John'));
}

Ten test wykonuje wiele czynności:

• weryfikuje kontrakt funkcji savePeople()
• nie dba o wdrożenie savePeople()
• dokumentuje przykładowe użycie savePeople()

Pamiętaj, że nadal możesz wyśmiewać / odgałęzić / sfałszować magazyn danych. W takim przypadku nie sprawdziłbym jawnych wywołań funkcji, ale wynik operacji. W ten sposób mój test jest przygotowany na przyszłe zmiany / refaktory.

Na przykład implementacja magazynu danych może zapewnić saveBulkPerson()metodę w przyszłości - teraz zmiana implementacji savePeople()użycia saveBulkPerson()nie przerwałaby testu jednostkowego, o ile saveBulkPerson()działa zgodnie z oczekiwaniami. A jeśli saveBulkPerson()jakoś nie zadziała zgodnie z oczekiwaniami, twój test jednostkowy to wykryje.

lub czy takie testy byłyby równoznaczne z testowaniem wbudowanej konstrukcji języka forEach?

Jak powiedziano, spróbuj przetestować oczekiwane wyniki i interfejs funkcji, a nie implementację (chyba że wykonujesz testy integracyjne - wtedy przydałoby się przechwytywanie określonych wywołań funkcji). Jeśli istnieje wiele sposobów implementacji funkcji, wszystkie powinny działać z testem jednostkowym.

Jeśli chodzi o twoją aktualizację pytania:

Testuj zmiany stanu! Np. Część ciasta zostanie wykorzystana. Zgodnie z wdrożeniem, upewnij się, że ilość użytego doughpasuje do panlub zapewnij, że doughjest zużyty. Upewnij się, że panzawiera pliki cookie po wywołaniu funkcji. Upewnij się, że ovenjest pusty / w takim samym stanie jak poprzednio.

W przypadku dodatkowych testów sprawdź przypadki skrajne: Co się stanie, jeśli ovennie będzie puste przed wywołaniem? Co się stanie, jeśli będzie za mało dough? Jeśli panjest już pełny?

Powinieneś być w stanie wydedukować wszystkie wymagane dane do tych testów z samego ciasta, naczynia i piekarnika. Nie trzeba przechwytywać wywołań funkcji. Traktuj funkcję tak, jakby jej implementacja nie była dla Ciebie dostępna!

W rzeczywistości większość użytkowników TDD pisze testy przed napisaniem funkcji, więc nie są zależni od faktycznej implementacji.

Do najnowszego dodatku:

Gdy użytkownik utworzy nowe konto, musi się zdarzyć kilka rzeczy: 1) należy utworzyć nowy rekord użytkownika w bazie danych 2) należy wysłać powitalny e-mail 3) adres IP użytkownika musi zostać zarejestrowany w celu oszustwa cele.

Chcemy więc stworzyć metodę, która łączy wszystkie kroki „nowego użytkownika”:

function createNewUser(validatedUserData, emailService, dataStore) {
    userId = dataStore.insertUserRecord(validateduserData);
    emailService.sendWelcomeEmail(validatedUserData);
    dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Dla takiej funkcji wyśmiewałbym / stub / fake (cokolwiek wydaje się bardziej ogólne) parametry dataStorei emailService. Ta funkcja nie wykonuje żadnych zmian stanów na żadnym parametrze, deleguje je do metod niektórych z nich. Chciałbym sprawdzić, czy wywołanie funkcji spowodowało 4 rzeczy:

• wstawił użytkownika do magazynu danych
• wysłał (lub przynajmniej wywołał odpowiednią metodę) wiadomość powitalną
• zarejestrował adres IP użytkowników w magazynie danych
• przekazał wszelkie napotkane wyjątki / błędy (jeśli występują)

Pierwsze 3 kontrole można wykonać za pomocą próbnych, stubów lub podróbek dataStorei emailService(naprawdę nie chcesz wysyłać wiadomości e-mail podczas testowania). Ponieważ musiałem to sprawdzić w przypadku niektórych komentarzy, oto różnice:

• Fałszywy to przedmiot, który zachowuje się tak samo jak oryginał i jest do pewnego stopnia nierozróżnialny. Jego kod można normalnie wykorzystać ponownie w testach. Może to być na przykład prosta baza danych w pamięci dla opakowania bazy danych.
• Kod pośredniczący po prostu implementuje tyle, ile jest potrzebne do spełnienia wymaganych operacji tego testu. W większości przypadków odcinek jest specyficzny dla testu lub grupy testów wymagających jedynie niewielkiego zestawu metod oryginału. W tym przykładzie może to być dataStoreimplementacja odpowiedniej wersji insertUserRecord()i recordIpAddress().
• Makieta to obiekt, który pozwala zweryfikować, w jaki sposób jest używany (najczęściej poprzez umożliwienie oceny wywołań jego metod). Staram się używać ich oszczędnie w testach jednostkowych, ponieważ przy ich użyciu faktycznie próbujesz przetestować implementację funkcji, a nie zgodność z interfejsem, ale nadal mają one swoje zastosowania. Istnieje wiele próbnych ram, które pomagają stworzyć tylko próbkę, której potrzebujesz.

Zauważ, że jeśli którakolwiek z tych metod zgłosi błąd, chcemy, aby błąd pojawił się w kodzie wywołującym, aby mógł obsłużyć błąd według własnego uznania. Jeśli jest wywoływany przez kod API, może przełożyć błąd na odpowiedni kod odpowiedzi HTTP. Jeśli jest wywoływany przez interfejs sieciowy, może przełożyć błąd na odpowiedni komunikat wyświetlany użytkownikowi i tak dalej. Chodzi o to, że ta funkcja nie wie, jak obsłużyć błędy, które mogą zostać zgłoszone.

Oczekiwane wyjątki / błędy są poprawnymi przypadkami testowymi: Potwierdzasz, że w przypadku wystąpienia takiego zdarzenia funkcja zachowuje się tak, jak się spodziewasz. Można to osiągnąć, pozwalając, aby odpowiedni obiekt próbny / fałszywy / skrótowy rzucał w razie potrzeby.

Istotą mojego pomieszania jest to, że do testowania jednostkowego takiej funkcji wydaje się konieczne powtórzenie dokładnej implementacji w samym teście (przez określenie, że metody są wywoływane na próbach w określonej kolejności) i to wydaje się nieprawidłowe.

Czasami trzeba to zrobić (choć w testach integracyjnych zależy Ci na tym). Częściej istnieją inne sposoby weryfikacji oczekiwanych efektów ubocznych / zmian stanu.

Weryfikacja dokładnych wywołań funkcji powoduje dość kruche testy jednostkowe: tylko niewielkie zmiany oryginalnej funkcji powodują, że zawodzą. Może to być pożądane lub nie, ale wymaga zmiany odpowiednich testów jednostkowych za każdym razem, gdy zmieniasz funkcję (czy to refaktoryzacja, optymalizacja, usuwanie błędów, ...).

Niestety, w takim przypadku test jednostkowy traci część swojej wiarygodności: ponieważ został zmieniony, nie potwierdza funkcji po zmianie zachowuje się tak samo jak poprzednio.

Na przykład rozważmy dodanie przez kogoś wywołania oven.preheat()(optymalizacja!) W przykładzie pieczenia ciasteczek:

• Jeśli wyśmiewałeś obiekt piekarnika, nie spodziewa się on wywołania i niepowodzenia testu, chociaż obserwowalne zachowanie metody nie uległo zmianie (mam nadzieję, że nadal masz garnek ciastek).
• Kod pośredniczący może, ale nie musi, zawieść, w zależności od tego, czy dodałeś tylko metody, które mają być testowane, czy cały interfejs z niektórymi sztucznymi metodami.
• Fałszywy nie powinien zawieść, ponieważ powinien implementować metodę (zgodnie z interfejsem)

W moich testach jednostkowych staram się być tak ogólny, jak to możliwe: jeśli implementacja ulegnie zmianie, ale widoczne zachowanie (z perspektywy osoby wywołującej) pozostanie takie samo, moje testy powinny zostać zaliczone. Idealnie, jedynym przypadkiem, w którym muszę zmienić istniejący test jednostkowy, powinna być naprawa błędu (testu, a nie testowanej funkcji).

Podstawową wartością, jaką zapewnia taki test, jest fakt, że implementacja jest refaktoryzowalna.

W swojej karierze przeprowadzałem wiele optymalizacji wydajności i często napotykałem problemy z dokładnie pokazanym wzorem: aby zapisać N jednostek w bazie danych, wykonać N wstawień. Zwykle bardziej wydajne jest wykonywanie wstawiania zbiorczego za pomocą pojedynczej instrukcji.

Z drugiej strony nie chcemy też przedwcześnie optymalizować. Jeśli zwykle ratujesz tylko 1-3 osoby na raz, pisanie zoptymalizowanej partii może być przesadą.

Przy odpowiednim teście jednostkowym możesz napisać go tak, jak go wdrożyłeś powyżej, a jeśli okaże się, że musisz go zoptymalizować, możesz to zrobić za pomocą siatki bezpieczeństwa automatycznego testu w celu wykrycia błędów. Oczywiście różni się to w zależności od jakości testów, więc testuj swobodnie i dobrze testuj.

Drugą zaletą testowania tego zachowania przez jednostkę jest służenie jako dokumentacja tego, do czego służy. Ten trywialny przykład może być oczywisty, ale biorąc pod uwagę następny punkt poniżej, może być bardzo ważny.

Trzecią zaletą, na którą zwrócili uwagę inni, jest możliwość testowania ukrytych detali, które są bardzo trudne do przetestowania za pomocą testów integracyjnych lub akceptacyjnych. Na przykład, jeśli istnieje wymóg, aby wszyscy użytkownicy byli zapisywani atomowo, możesz napisać testową skrzynkę, która da ci pewność, że zachowuje się zgodnie z oczekiwaniami, a także służy jako dokumentacja dla wymagania, które może nie być oczywiste dla nowych programistów.

Dodam myśl, którą dostałem od instruktora TDD. Nie testuj metody. Przetestuj zachowanie. Innymi słowy, nie testujesz, czy to savePeopledziała, testujesz, czy wielu użytkowników można zapisać w jednym połączeniu.

Przekonałem się, że moja zdolność do przeprowadzania testów jednostkowych jakości i TDD poprawia się, kiedy przestałem myśleć o testach jednostkowych jako o sprawdzaniu działania programu, ale raczej sprawdzają, czy jednostka kodu działa zgodnie z oczekiwaniami . Te są różne. Nie sprawdzają, czy to działa, ale sprawdzają, czy działa tak, jak sądzę. Kiedy zacząłem tak myśleć, moja perspektywa się zmieniła.

Powinien bakeCookies()zostać przetestowany? Tak.

Jak taką funkcję należy testować jednostkowo, zakładając, że tak powinno być? Trudno mi wyobrazić sobie jakikolwiek test jednostkowy, który nie wyśmiewałby ciasta, patelni i piekarnika, a następnie twierdził, że wywoływane są metody.

Nie całkiem. Przyjrzyj się dokładnie, CO ma robić funkcja - ma ustawić ovenobiekt w określonym stanie. Patrząc na kod, wydaje się, że stany obiektów pani doughnie mają tak naprawdę większego znaczenia. Powinieneś więc przekazać ovenobiekt (lub wyśmiewać go) i upewnić się, że jest on w określonym stanie na końcu wywołania funkcji.

Innymi słowy, powinieneś stwierdzić, że bakeCookies()upiekły ciasteczka .

W przypadku bardzo krótkich funkcji testy jednostkowe mogą wydawać się czymś więcej niż tautologią. Ale nie zapominaj, że twój program będzie trwał znacznie dłużej niż czas, w którym go piszesz. Ta funkcja może, ale nie musi ulec zmianie w przyszłości.

Testy jednostkowe spełniają dwie funkcje:

1. Sprawdza, czy wszystko działa. Jest to najmniej przydatna funkcja testów jednostkowych i wydaje się, że wydaje się, że rozważasz tę funkcjonalność tylko przy zadawaniu pytania.

2. Sprawdza, czy przyszłe modyfikacje programu nie psują funkcjonalności, która została wcześniej zaimplementowana. Jest to najbardziej przydatna funkcja testów jednostkowych i zapobiega wprowadzaniu błędów do dużych programów. Jest przydatny w normalnym kodowaniu podczas dodawania funkcji do programu, ale jest bardziej użyteczny w refaktoryzacji i optymalizacjach, w których podstawowe algorytmy wdrażające program są dramatycznie zmieniane bez zmiany jakiegokolwiek możliwego do zaobserwowania zachowania programu.

Nie testuj kodu wewnątrz funkcji. Zamiast tego sprawdź, czy funkcja robi to, co mówi. Kiedy spojrzysz na testy jednostkowe w ten sposób (testowanie funkcji, a nie kodu), zdasz sobie sprawę, że nigdy nie testujesz konstrukcji języka, ani nawet logiki aplikacji. Testujesz interfejs API.

Czy metoda savePeople () powinna być testowana jednostkowo, czy może to oznaczać testowanie wbudowanej konstrukcji języka forEach?

Tak. Ale możesz to zrobić w sposób, który po prostu ponownie przetestuje konstrukcję.

Należy tutaj zauważyć, jak zachowuje się ta funkcja, gdy savePersonawaria jest w połowie? Jak to ma działać?

Jest to rodzaj subtelnego zachowania, które zapewnia funkcja, którą należy egzekwować za pomocą testów jednostkowych.

Kluczem tutaj jest twoje spojrzenie na określoną funkcję jako banalną. Większość programowania jest trywialna: przypisz wartość, zrób matematykę, podejmij decyzję: jeśli to, to kontynuuj pętlę, aż ... W izolacji wszystkie trywialne. Właśnie przejrzałeś 5 pierwszych rozdziałów każdej książki uczącej języka programowania.

Fakt, że pisanie testu jest tak łatwe, powinien być znakiem, że Twój projekt nie jest taki zły. Czy wolisz projekt, który nie jest łatwy do przetestowania?

„To się nigdy nie zmieni”. tak zaczyna się większość nieudanych projektów. Test jednostkowy określa tylko, czy jednostka działa zgodnie z oczekiwaniami w określonych okolicznościach. Zdobądź go, a wtedy możesz zapomnieć o szczegółach jego implementacji i po prostu go użyć. Wykorzystaj przestrzeń mózgu do następnego zadania.

Wiedza o tym, że wszystko działa zgodnie z oczekiwaniami, jest bardzo ważna i nie jest trywialna w dużych projektach, a zwłaszcza w dużych zespołach. Jeśli jest coś, co łączy programistów, to fakt, że wszyscy mieliśmy do czynienia z okropnym kodem innej osoby. Możemy przynajmniej przeprowadzić testy. W razie wątpliwości napisz test i przejdź dalej.

Czy metoda savePeople () powinna być testowana jednostkowo, czy może to oznaczać testowanie wbudowanej konstrukcji języka forEach?

Odpowiedział na to już @BryanOakley, ale mam dodatkowe argumenty (tak sądzę):

Po pierwsze, test jednostkowy służy do testowania wykonania umowy, a nie wdrożenia interfejsu API; test powinien ustalić warunki wstępne, a następnie wywołać, a następnie sprawdzić efekty, skutki uboczne, niezmienniki i warunki po. Kiedy decydujesz, co przetestować, implementacja interfejsu API nie ma (i nie powinna) mieć znaczenia .

Po drugie, twój test będzie tam, aby sprawdzić niezmienniki, gdy funkcja się zmieni . Fakt, że teraz się nie zmienia , nie oznacza, że ​​nie powinieneś mieć testu.

Po trzecie, warto wdrożyć trywialny test, zarówno w podejściu TDD (który tego wymaga), jak i poza nim.

Pisząc C ++, na moich zajęciach piszę trywialny test, który tworzy instancję obiektu i sprawdza niezmienniki (przypisywalne, zwykłe itp.). Zaskakujące było to, ile razy test ten był przerywany podczas programowania (np. Przez pomyłkę dodanie do klasy niemożliwego do przeniesienia członka).

Myślę, że twoje pytanie sprowadza się do:

Jak mogę przetestować funkcję typu void bez testowania integracji?

Jeśli zmienimy funkcję pieczenia plików cookie, aby na przykład zwracać pliki cookie, natychmiast stanie się oczywiste, jaki powinien być test.

Jeśli musimy wywołać pan.GetCookies po wywołaniu funkcji, możemy jednak zapytać, czy jest to „test integracji”, czy „ale czy nie testujemy tylko obiektu panoramowania?”.

Myślę, że masz rację pod tym względem, że przeprowadzanie testów jednostkowych z wyśmiewanym wszystkim i sprawdzanie funkcji xy i z nazwano brakiem wartości.

Ale! Argumentowałbym, że w takim przypadku powinieneś zrefaktoryzować swoje nieważne funkcje, aby zwrócić testowalny wynik LUB użyć rzeczywistych obiektów i wykonać test integracji

--- Aktualizacja dla przykładu createNewUser

• w bazie danych należy utworzyć nowy rekord użytkownika
• powitalna wiadomość e-mail musi zostać wysłana
• adres IP użytkownika musi zostać zarejestrowany w celu oszustwa.

OK, więc tym razem wynik funkcji nie jest łatwo zwracany. Chcemy zmienić stan parametrów.

W tym miejscu jestem nieco kontrowersyjny. Tworzę konkretne symulacje dla parametrów stanowych

proszę, drodzy czytelnicy, spróbujcie opanować swój gniew!

więc...

var validatedUserData = new UserData(); //we can use the real object for this
var emailService = new MockEmailService(); //a simple mock which saves sentEmails to a List<string>
var dataStore = new MockDataStore(); //a simple mock which saves ips to a List<string>

//run the test
target.createNewUser(validatedUserData, emailService, dataStore);

//check the results
Assert.AreEqual(1, emailService.EmailsSent.Count());
Assert.AreEqual(1, dataStore.IpsRecorded.Count());
Assert.AreEqual(1, dataStore.UsersSaved.Count());

Oddziela to szczegóły implementacji testowanej metody od pożądanego zachowania. Alternatywne wdrożenie:

function createNewUser(validatedUserData, emailService, dataStore) {
  userId = dataStore.bulkInsedrtUserRecords(new [] {validateduserData});
  emailService.addEmailToQueue(validatedUserData);
  emailService.ProcessQueue();
  dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Nadal przejdzie test jednostkowy. Ponadto masz tę zaletę, że możesz ponownie użyć próbnych obiektów w testach, a także wstrzyknąć je do aplikacji na potrzeby interfejsu użytkownika lub testów integracyjnych.

Powinieneś także przetestować bakeCookies- co przyniosłoby / powinno e..g bakeCookies(egg, pan, oven)? Jajko sadzone czy wyjątek? Na własną rękę, ani panteż nie ovenbędą dbać o rzeczywistych składników, ponieważ żaden z nich nie mają, ale bakeCookiespowinny zazwyczaj wydajność ciasteczek. Bardziej ogólnie może to zależeć od tego, jak doughuzyskuje się i czy jest jakaś szansa, że staje się zwykłym egglub np waterzamiast.