Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00388 008789 10443483 na godz. na dobę w sumie
Ruby on Rails. Zaawansowane programowanie - książka
Ruby on Rails. Zaawansowane programowanie - książka
Autor: Liczba stron: 488
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1844-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> ruby - programowanie
Porównaj ceny (książka, ebook (-87%), audiobook).
Naucz się:

Ruby on Rails (RoR) to sieciowy szkielet open source, pozwalający utrzymać równowagę pomiędzy łatwością programowania a jego produktywnością. To, co odróżnia ten framework od innych, to przewaga konwencji nad konfiguracją, co ułatwia budowę i zrozumienie aplikacji. Prostota i intuicyjność tego środowiska pomagają uniknąć powtórzeń i sprawiają, że programowanie jest łatwiejsze niż kiedykolwiek. W ciągu lat w RoR wprowadzono szereg zmian, związanych z ewolucją technik programistycznych. Poza tym wystarczającą rekomendacją dla tego środowiska wydaje się uznanie wyrażane przez takie osoby, jak James Duncan Davidson (twórca Tomcata i Anta), Bruce Perens (Open Source Luminary), Nathan Torkington (O'Reilly, OSCON) i wiele innych.

Książka 'Ruby on Rails. Zaawansowane programowanie' jest przeznaczona dla średnio i bardzo zaawansowanych programistów Rails. Autor zakłada, że Czytelnik zna język Ruby i przeczytał chociaż jedną z dostępnych książek, wprowadzających w świat Rails, lub ma za sobą inną formę podstawowego kursu. Czytelnik tej książki powinien wiedzieć, jak stworzyć prostą aplikację Rails. W tej publikacji znajdzie natomiast szereg odpowiedzi na pytania pojawiające się po napisaniu pierwszej aplikacji. Autor wyjaśnia, jak poradzić sobie z użytkownikami i zabezpieczeniami, opisuje obsługę stref czasowych i problemy związane z użytkowaniem aplikacji w różnych stronach świata oraz podaje sposoby zabezpieczania strony przed atakami. Czytelnik znajdzie tu porady dotyczące zarządzania zespołem programistów Rails i kodem źródłowym, automatyzacji powtarzalnych zadań i wdrażania aplikacji w środowisku produkcyjnym, a także sposobów korzystania z nieustannie powstających rozszerzeń Rails.

Poszerz swoją wiedzę na temat środowiska Ruby on Rails.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Ruby on Rails. Zaawansowane programowanie Autor: Noel Rappin T‡umaczenie: Justyna Walkowska ISBN: 978-83-246-1844-6 Tytu‡ orygina‡u: Professional Ruby On Rails Format: 172x245, stron: 488 Naucz siŒ: (cid:149) tworzy(cid:230) testy automatyczne dla wszystkich czŒ(cid:156)ci aplikacji Rails (cid:149) wdra¿a(cid:230) aplikacje napisane w Ruby przy u¿yciu Capistrano, Mongrel i Apache (cid:149) broni(cid:230) stron przed atakami Ruby on Rails (RoR) to sieciowy szkielet open source, pozwalaj„cy utrzyma(cid:230) r(cid:243)wnowagŒ pomiŒdzy ‡atwo(cid:156)ci„ programowania a jego produktywno(cid:156)ci„. To, co odr(cid:243)¿nia ten framework od innych, to przewaga konwencji nad konfiguracj„, co u‡atwia budowŒ i zrozumienie aplikacji. Prostota i intuicyjno(cid:156)(cid:230) tego (cid:156)rodowiska pomagaj„ unikn„(cid:230) powt(cid:243)rzeæ i sprawiaj„, ¿e programowanie jest ‡atwiejsze ni¿ kiedykolwiek. W ci„gu lat w RoR wprowadzono szereg zmian, zwi„zanych z ewolucj„ technik programistycznych. Poza tym wystarczaj„c„ rekomendacj„ dla tego (cid:156)rodowiska wydaje siŒ uznanie wyra¿ane przez takie osoby, jak James Duncan Davidson (tw(cid:243)rca Tomcata i Anta), Bruce Perens (Open Source Luminary), Nathan Torkington (O(cid:146)Reilly, OSCON) i wiele innych. Ksi„¿ka (cid:132)Ruby on Rails. Zaawansowane programowanie(cid:148) jest przeznaczona dla (cid:156)rednio i bardzo zaawansowanych programist(cid:243)w Rails. Autor zak‡ada, ¿e Czytelnik zna jŒzyk Ruby i przeczyta‡ chocia¿ jedn„ z dostŒpnych ksi„¿ek, wprowadzaj„cych w (cid:156)wiat Rails, lub ma za sob„ inn„ formŒ podstawowego kursu. Czytelnik tej ksi„¿ki powinien wiedzie(cid:230), jak stworzy(cid:230) prost„ aplikacjŒ Rails. W tej publikacji znajdzie natomiast szereg odpowiedzi na pytania pojawiaj„ce siŒ po napisaniu pierwszej aplikacji. Autor wyja(cid:156)nia, jak poradzi(cid:230) sobie z u¿ytkownikami i zabezpieczeniami, opisuje obs‡ugŒ stref czasowych i problemy zwi„zane z u¿ytkowaniem aplikacji w r(cid:243)¿nych stronach (cid:156)wiata oraz podaje sposoby zabezpieczania strony przed atakami. Czytelnik znajdzie tu porady dotycz„ce zarz„dzania zespo‡em programist(cid:243)w Rails i kodem (cid:159)r(cid:243)d‡owym, automatyzacji powtarzalnych zadaæ i wdra¿ania aplikacji w (cid:156)rodowisku produkcyjnym, a tak¿e sposob(cid:243)w korzystania z nieustannie powstaj„cych rozszerzeæ Rails. (cid:149) Tworzenie zasob(cid:243)w (cid:149) Kontrola kodu przy pomocy Subversion (SVN) (cid:149) Budowanie i automatyzacja (cid:149) Nawigacja i portale spo‡eczno(cid:156)ciowe (cid:149) Opieka nad bazami danych (cid:149) JavaScript w Rails (cid:149) NarzŒdzia do testowania (cid:149) Metaprogramowanie (cid:149) Tworzenie wtyczek Poszerz swoj„ wiedzŒ na temat (cid:156)rodowiska Ruby on Rails Spis treści O autorze ..................................................................................................................................................13 Podziękowania .........................................................................................................................................15 Wstęp ........................................................................................................................................................17 Kto powinien przeczytać tę książkę ................................................................................ 17 Struktura książki .......................................................................................................... 18 Co jest potrzebne do uruchomienia przykładów ............................................................... 19 Konwencje ................................................................................................................... 20 Kod źródłowy ............................................................................................................... 20 Rozdział 1. Tworzenie zasobów ...............................................................................................................21 Od czego zacząć? ......................................................................................................... 22 Przepis na przepisy ....................................................................................................... 22 REST — reszta tej historii ............................................................................................. 24 Czym jest REST? ..................................................................................................... 24 Dlaczego REST? ...................................................................................................... 27 Tworzymy pierwsze zasoby ............................................................................................ 27 Migracje ................................................................................................................. 28 Przekierowania ....................................................................................................... 29 Kontrolery .............................................................................................................. 32 Widoki .................................................................................................................... 36 Wyświetlanie przekierowań ...................................................................................... 37 Tworzymy składniki ....................................................................................................... 37 Konfiguracja bazy danych ......................................................................................... 38 Dopasowanie testów do zagnieżdżonych zasobów ...................................................... 39 Tworzymy edytor przepisów ........................................................................................... 42 Dodajemy składniki ................................................................................................. 43 Sprawdzamy poprawność HTML ............................................................................... 43 Parsujemy składniki ................................................................................................ 46 Podrasowujemy stronę ............................................................................................ 49 Testowanie tworzenia zasobów ................................................................................ 50 Dodajemy fragmenty techniki Ajax ............................................................................ 54 Źródła ......................................................................................................................... 57 Podsumowanie ............................................................................................................ 58 6 Ruby on Rails. Zaawansowane programowanie Rozdział 2. Kontrola kodu za pomocą Subversion .................................................................................59 Kontrola kodu ................................................................................................................... 59 Tworzenie repozytorium ...................................................................................................... 62 Wypełnianie repozytorium .............................................................................................. 63 Pobieranie i dodawanie plików ................................................................................. 63 Co ignorować? ........................................................................................................ 64 Pliki bazodanowe w repozytorium ............................................................................. 65 Oznaczanie plików wykonywalnych ............................................................................ 66 Wysyłanie zmian ..................................................................................................... 67 Cykl życia repozytorium ................................................................................................. 68 Wysyłanie zwykłych zmian ........................................................................................ 68 Pobieranie nowszych wersji plików i konflikty ............................................................. 69 Zmiany na poziomie plików ...................................................................................... 70 Konfiguracja serwera Subversion za pomocą svnserve .................................................... 71 Życie na krawędzi ......................................................................................................... 73 Korzystanie z określonej wersji Rails ........................................................................ 74 Rake a życie na krawędzi ......................................................................................... 76 Co słychać u RDoc? ...................................................................................................... 77 Źródła ......................................................................................................................... 79 Podsumowanie ............................................................................................................ 79 Rozdział 3. Dodawanie użytkowników ....................................................................................................81 Tworzenie użytkowników ............................................................................................... 81 Formularz tworzenia nowego użytkownika ........................................................................ 82 Refaktoryzacja formularzy za pomocą FormBuilder .......................................................... 86 Przechowywanie zaszyfrowanych haseł ........................................................................... 90 Uwierzytelnianie ........................................................................................................... 93 Przekierowania ....................................................................................................... 93 Testy ..................................................................................................................... 93 Kontroler ................................................................................................................ 95 Widoki .................................................................................................................... 96 Korzystanie z uwierzytelniania .................................................................................. 99 Dodawanie ról użytkowników .................................................................................. 100 Ochrona przed botami za pomocą e-maili uwierzytelniających ......................................... 102 Generowanie modelu i migracji ............................................................................... 103 Najpierw testy ....................................................................................................... 104 Logika kontrolera .................................................................................................. 105 Wysyłanie e-maila ................................................................................................. 106 CAPTCHA ................................................................................................................... 108 Tworzenie obiektu CAPTCHA sterowanego testami ................................................... 109 Implementacja obiektu CAPTCHA ........................................................................... 110 Wdrażanie CAPTCHA .............................................................................................. 112 Sesje i ciasteczka ...................................................................................................... 116 Strategie tworzenia ciasteczek umożliwiających trwałe logowanie .............................. 116 Mechanizm trwałego logowania — najpierw testy ..................................................... 117 Cykl życia ciasteczka ............................................................................................. 119 Sprawdzanie ważności ciasteczek .......................................................................... 120 Źródła ....................................................................................................................... 122 Podsumowanie .......................................................................................................... 123 Spis treści 7 Rozdział 4. Budowanie i automatyzacja ................................................................................................125 Co Rake może zrobić dla Ciebie? ................................................................................. 126 Zadania Rake związane z bazami danych ................................................................ 126 Zadania Rake związane z dokumentacją ................................................................. 128 Zadania Rake związane z testowaniem ................................................................... 129 Zadania Rake związane z usuwaniem plików ........................................................... 130 Zadania Rake związane z wersją Rails .................................................................... 130 Inne zadania Rake ................................................................................................ 131 Co Ty możesz zrobić dla Rake? .................................................................................... 132 Proste zadanie Rake ............................................................................................. 132 Zadania z zależnościami ........................................................................................ 133 Zadania plikowe .................................................................................................... 136 Wykorzystanie Rails w Rake ................................................................................... 137 Testowanie zadań Rake ......................................................................................... 138 Ciągła integracja ........................................................................................................ 140 ZenTest ............................................................................................................... 141 CruiseControl.rb .................................................................................................... 142 Źródła ....................................................................................................................... 144 Podsumowanie .......................................................................................................... 145 Rozdział 5. Nawigacja i portale społecznościowe ................................................................................147 Menu i boczne paski nawigacyjne ................................................................................ 147 Menu jednopoziomowe .......................................................................................... 147 Pamięć cache obiektów ......................................................................................... 152 Oznaczanie ................................................................................................................ 154 Instalacja pluginu Acts As Taggable ........................................................................ 154 Dodawanie tagów do modelu ................................................................................. 155 Tagi i interfejs użytkownika .................................................................................... 157 Wyszukiwanie informacji na stronie .............................................................................. 166 Wyszukiwanie z wykorzystaniem SQL ...................................................................... 166 Wyszukiwanie z wykorzystaniem Ferret .................................................................... 169 Stronicowanie ............................................................................................................ 175 will_paginate ........................................................................................................ 175 paginating_find ..................................................................................................... 176 Źródła ....................................................................................................................... 176 Podsumowanie .......................................................................................................... 177 Rozdział 6. Opieka nad bazami danych ..................................................................................................179 Dostęp do spadku ...................................................................................................... 180 Niekonwencjonalne nazewnictwo ................................................................................. 183 Testowanie zewnętrznej bazy danych w oparciu o pliki z danymi testowymi ...................... 184 Tworzenie związków pomiędzy bazami danych ............................................................... 189 Definiowanie funkcjonalności ................................................................................. 189 Tworzenie modelu pośrednika ................................................................................ 191 Połączenia pomiędzy klasami ................................................................................. 191 Inny mechanizm dostępu do danych ....................................................................... 192 Zyski z bycia normalnym ............................................................................................. 194 Trochę teorii ......................................................................................................... 194 Trochę praktyki ..................................................................................................... 195 Wywołania zwrotne ActiveRecord ............................................................................ 197 Częsty przypadek .................................................................................................. 199 8 Ruby on Rails. Zaawansowane programowanie Asocjacje polimorficzne ............................................................................................... 199 Ochrona bazy danych .................................................................................................. 201 Ochrona przed SQL Injection za pomocą metody find ............................................... 201 Transakcje ................................................................................................................. 202 Asocjacje jako sposób ochrony przed kradzieżą danych ............................................ 203 Źródła ....................................................................................................................... 203 Podsumowanie .......................................................................................................... 204 Rozdział 7. Narzędzia do testowania ...................................................................................................205 Programowanie sterowane testami .............................................................................. 205 Pokrycie całości ......................................................................................................... 207 Instalacja rcov ...................................................................................................... 207 Jak korzystać z rcov w Rails? ................................................................................. 208 Testowanie za pomocą atrap ....................................................................................... 211 FlexMock .............................................................................................................. 212 Specyfikacja obiektów i metod typu stub ................................................................. 214 Oczekiwania atrap ................................................................................................. 215 Projektowanie w oparciu o zachowanie ......................................................................... 217 Instalacja RSpec ................................................................................................... 217 Pisanie specyfikacji RSpec .................................................................................... 219 Jak uzyskać funkcjonalności RSpec bez RSpec? ........................................................... 227 Testowanie widoków ............................................................................................. 227 Bardziej naturalna składnia testowania ................................................................... 230 Lepsze dane do testów ......................................................................................... 231 Testowanie pomocników ........................................................................................ 232 Źródła ....................................................................................................................... 234 Podsumowanie .......................................................................................................... 235 Rozdział 8. JavaScript w Rails .............................................................................................................237 Powrót do przeszłości ................................................................................................. 238 Usuwamy zduplikowany kod ................................................................................... 239 Trochę gracji ......................................................................................................... 243 Łatwa i przyjemna integracja kodu JavaScript ................................................................ 248 Podpowiedzi ......................................................................................................... 248 Edycja bezpośrednia .............................................................................................. 251 Autocomplete ....................................................................................................... 254 Pisanie kodu JavaScript w języku Ruby ......................................................................... 255 Przykład RJS ......................................................................................................... 256 Inne metody RJS ................................................................................................... 258 Okienka typu lightbox ............................................................................................ 259 Jak testować RJS? ................................................................................................ 261 Ochrona przed atakiem Cross-Site Scripting ................................................................. 262 Źródła ....................................................................................................................... 264 Podsumowanie .......................................................................................................... 264 Rozdział 9. Rozmowy z siecią ...............................................................................................................265 ActiveResource .......................................................................................................... 265 Strona kliencka REST ............................................................................................ 266 Aktywacja zasobów ............................................................................................... 267 Wytwarzanie danych przez usługi sieciowe .................................................................... 270 Wytwarzanie XML .................................................................................................. 270 Szablony budujące ................................................................................................ 272 Spis treści 9 Wytwarzanie szybko zmieniających się danych ......................................................... 273 Wytwarzanie danych JSON i YAML .......................................................................... 279 Konsumowanie usług sieciowych ................................................................................. 281 Źródła ....................................................................................................................... 282 Podsumowanie .......................................................................................................... 283 Rozdział 10. Umiędzynaradawianie aplikacji .......................................................................................285 Kogo obchodzi czas? .................................................................................................. 285 Data i czas ........................................................................................................... 286 Zapis dat i godzin a strefy czasowe ........................................................................ 287 Wprowadzanie dat ................................................................................................. 290 Działania na datach i wyświetlanie dat .................................................................... 295 Umiędzynaradawianie za pomocą Globalize .................................................................. 298 Korzystanie z pluginu Globalize .............................................................................. 298 Formatowanie lokalne ........................................................................................... 300 Tłumaczenie ......................................................................................................... 301 Śledzenie przekierowań ......................................................................................... 306 Źródła ....................................................................................................................... 307 Podsumowanie .......................................................................................................... 307 Rozdział 11. Sztuki piękne ......................................................................................................................309 Zaczynamy ................................................................................................................. 309 Pakiety graficzne ................................................................................................... 310 Instalacja w systemie Windows .............................................................................. 310 Instalacja w systemie Mac OS X ............................................................................. 311 Instalacja w systemie Linux ................................................................................... 312 Przesyłanie plików do Rails ......................................................................................... 312 Konfiguracja danych attachment_fu ........................................................................ 313 Tworzenie modelu attachment_fu ........................................................................... 314 Testowanie attachment_fu ..................................................................................... 315 Dodawanie formularza attachment_fu ..................................................................... 317 Wyświetlanie obrazków przez attachment_fu ............................................................ 318 Korzystanie z bibliotek graficznych ............................................................................... 320 ImageScience ....................................................................................................... 320 RMagick ............................................................................................................... 321 MiniMagick ........................................................................................................... 327 Wykresy ..................................................................................................................... 330 Gruff .................................................................................................................... 330 Sparklines ............................................................................................................ 333 Źródła ....................................................................................................................... 335 Podsumowanie .......................................................................................................... 335 Rozdział 12. Wdrażanie aplikacji ..........................................................................................................337 Capistrano ................................................................................................................. 337 Zaczynamy pracę z Capistrano ............................................................................... 338 Podstawowe zadania Capistrano ............................................................................ 340 Dopasowanie Capistrano do własnych potrzeb ........................................................ 344 Wdrażanie etapami ............................................................................................... 349 Mongrel ..................................................................................................................... 350 Zaczynamy ........................................................................................................... 350 Proste wdrożenie .................................................................................................. 352 10 Ruby on Rails. Zaawansowane programowanie Wdrażanie z wykorzystaniem wielu instancji serwera ................................................ 353 Mongrel, Apache i Ty ............................................................................................. 357 Źródła ....................................................................................................................... 358 Podsumowanie .......................................................................................................... 358 Rozdział 13. Wydajność ..........................................................................................................................361 Pomiary ..................................................................................................................... 361 Railsbench ........................................................................................................... 362 Wydajność poszczególnych składowych programu .................................................... 368 Poprawa wydajności ................................................................................................... 375 Przechowywanie sesji ............................................................................................ 377 Problemy z ActiveRecord i bazami danych ............................................................... 380 Caching ..................................................................................................................... 384 Caching stron ....................................................................................................... 385 Caching akcji ........................................................................................................ 386 Caching fragmentów widoków ................................................................................ 386 Usuwanie starych plików cache .............................................................................. 387 Przechowywanie cache ........................................................................................... 388 Źródła ....................................................................................................................... 388 Podsumowanie .......................................................................................................... 389 Rozdział 14. Poziom meta .......................................................................................................................391 Eval i wiązania ........................................................................................................... 392 Introspekcja ............................................................................................................... 394 Klasy, metaklasy i singletony ...................................................................................... 397 Klasy i obiekty ...................................................................................................... 397 Singletony ............................................................................................................ 399 Monkey patching i duck punching ................................................................................ 402 O tym, jak podczas małpiego łatania nie pośliznąć się na skórce od banana .............. 403 Alias .................................................................................................................... 404 Jak robią to pluginy ............................................................................................... 406 Acts As Reviewable ............................................................................................... 406 Brakujące metody ...................................................................................................... 409 Dynamiczne definiowanie metod .................................................................................. 411 Źródła ....................................................................................................................... 413 Podsumowanie .......................................................................................................... 414 Rozdział 15. Tworzenie pluginów ..........................................................................................................415 Korzystanie z pluginów ................................................................................................ 415 Instalacja pluginów ............................................................................................... 416 Repozytoria z pluginami ......................................................................................... 417 Tworzenie pluginu ....................................................................................................... 418 Pisanie generatora ..................................................................................................... 421 Podstawowe funkcjonalności generatora ................................................................. 421 Klasa generatora .................................................................................................. 422 Manifest generatora .............................................................................................. 423 Testowanie generatorów ........................................................................................ 424 Pisanie testu generatora ....................................................................................... 426 GeneratorTestHelper ............................................................................................. 428 Migracja, która pomyślnie przechodzi testy .............................................................. 430 Spis treści 11 Pisanie pluginu .......................................................................................................... 430 Konfiguracja testów ActiveRecord ................................................................................ 430 Struktura Acts As Reviewable ...................................................................................... 434 Dystrybucja pluginów .................................................................................................. 437 Źródła ....................................................................................................................... 437 Podsumowanie .......................................................................................................... 438 Rozdział 16. Rails bez Ruby? .................................................................................................................439 Alternatywy dla ERB .................................................................................................... 439 Markaby ............................................................................................................... 440 Haml .................................................................................................................... 443 Liquid .................................................................................................................. 449 JRuby on JRails .......................................................................................................... 453 Zaczynamy ........................................................................................................... 453 Przekraczanie granic .............................................................................................. 455 Uruchamianie JRails .............................................................................................. 457 Wdrażanie z wykorzystaniem plików WAR ................................................................ 459 GlassFish ............................................................................................................. 460 Źródła ....................................................................................................................... 461 Podsumowanie .......................................................................................................... 461 Dodatek A Co należy zainstalować? .....................................................................................................463 Różne platformy ......................................................................................................... 463 Linux .................................................................................................................... 463 Mac OS X ............................................................................................................. 463 Windows .............................................................................................................. 464 Ruby ......................................................................................................................... 464 Rails ......................................................................................................................... 465 Subversion ................................................................................................................ 465 Bazy danych ............................................................................................................... 465 Mongrel ..................................................................................................................... 466 Edytor tekstu ............................................................................................................. 466 Za jednym zamachem ................................................................................................. 467 Dodatek B Środowiska sieciowe zainspirowane Rails .......................................................................469 CakePHP ................................................................................................................... 469 Camping .................................................................................................................... 469 Django ...................................................................................................................... 470 Grails ........................................................................................................................ 470 Merb ......................................................................................................................... 471 TurboGears ................................................................................................................ 471 Skorowidz .............................................................................................................................................473 7 Narzędzia do testowania Znaczną część tej książki poświęcam testom automatycznym. Robię to dlatego, że uważam je za jedną z najważniejszych metod dbania o jakość i stabilność kodu. Do tej pory skupiałem się na standardowej strukturze Test::Unit, czyli podstawowym zestawie narzędzi sprawdza- jących poprawność kodu w języku Ruby. Test::Unit stanowi bardzo ważną część testowania automatycznego, jednak nie jest jedynym narzędziem, z którego powinien korzystać pro- gramista chcący przeprowadzić kompletne testy swojej aplikacji. W tym rozdziale przedstawię różne narzędzia do testowania aplikacji i postaram się prze- konać Czytelnika, że każde z nich wnosi nową jakość do programowania sterowanego te- stami. Pokażę, jak zmierzyć ilość kodu pokrytego testami oraz jak wykorzystać obiekty- atrapy w celu poprawy jakości kodu i przetestowania jego trudno dostępnych części. Omówię także narzędzia do testów sterowanych zachowaniem, które są techniką intensywnie wyko- rzystującą atrapy. Na koniec powiem, jak oddzielić testy kontrolera od testów widoku. Programowanie sterowane testami Testy automatyczne zostały po raz pierwszy uznane za standardową część procesu wytwa- rzania oprogramowania, gdy stały się jedną z głównych praktyk programowania ekstremalne- go (XP). Ta metodologia jest często źle rozumiana, jednak — niezależnie od XP, a częściowo również dzięki niemu — praktyki wcześniej określane mianem Test-First Programming (programowanie „najpierw testy”) są teraz znane pod nazwą Test-Driven Development (pro- gramowanie sterowane testami, w skrócie TDD). TDD składa się z trzech kroków, które powtarza się w kółko, aż do ukończenia aplikacji. Oto one: 1. Napisz prosty test, który będzie sprawdzał coś, czego Twój program jeszcze nie robi. Jeśli ten krok zajmuje więcej niż kilka minut, oznacza to, że próbujesz zrobić za dużo lub że struktura aplikacji jest zbyt złożona. Test powinien zakończyć się niepowodzeniem, ponieważ nowa funkcjonalność nie została jeszcze dodana do systemu. Uruchom test, aby upewnić się, że aplikacja rzeczywiście go nie przejdzie. 206 Ruby on Rails. Zaawansowane programowanie 2. Stwórz prosty kod, dzięki któremu test będzie kończył się sukcesem. Istotne jest, by nie zastanawiać się nad tym, czy aplikacja przejdzie następny test — skup się tylko na bieżącym teście. 3. Przeprowadź refaktoryzację. Możliwe, że w wyniku zmian wprowadzonych w aplikacji w poprzednich krokach pojawiły się niepożądane elementy, takie jak duplikacja kodu. Wyczyść je od razu i upewnij się, że aplikacja pomyślnie przechodzi napisane do tej pory testy. Następnie przejdź do kolejnego testu. Przykłady zamieszczone w tej książce najczęściej przedstawiają pierwszą wersję testu oraz końcowy kod. Raczej nie omawiam procesu refaktoryzacji, który ma na celu wyczyszczenie kodu. Czasami przedstawiam kilka powiązanych ze sobą testów, mimo że w rzeczywistości kod powstawał zgodnie z przedstawionymi powyżej krokami — po jednym teście naraz. Można spotkać się z różnymi opiniami na temat prostoty kodu dodawanego w drugim kroku. Niektórzy programiści posuwają się do ekstremalnego stosowania stałych. Jeśli test ma postać: assert_equals(7, x.foo) postulują oni rozpoczęcie implementacji od def foo return 7 end Jeśli foo nie ma być metodą zwracającą stałą wartość, należy dodać inny test, który nie za- kończy się sukcesem. W końcu powinno się okazać, że łatwiej jest napisać całą metodę, niż dodawać zwracanie nowych stałych. Moim zdaniem takie rozwiązanie jest pewną przesadą (chociaż w praktyce do pisania właściwej metody dochodzi się bardzo szybko). Sam stosuję podejście polegające na tworzeniu „najprostszego kodu, który można by uznać za imple- mentację tej funkcji”, bądź „najprostszego kodu, który zadziałałby, nawet gdybym nie wie- dział dokładnie, jakie wartości zostaną podane podczas testów”. Warto również napisać osob- ne przypadki testowe dla sytuacji, w których mogą pojawić się błędy po przekazaniu pustych argumentów. Pod żadnym pozorem nie wolno pomijać kroku związanego z refaktoryzacją, ponieważ to wtedy odbywa się właściwe projektowanie. Częsta refaktoryzacja jest prosta i mało kosz- towna, a na dodatek zmniejsza ona prawdopodobieństwo tego, że na późniejszym etapie konieczne będzie przeprowadzenie wielkich porządków. Zgodnie z teorią aplikacja wytwarzana zgodnie z tym procesem zawsze jest w całości pokryta testami i jest możliwie prosta. Są to bardzo ważne cechy — aplikacja napisana w oparciu o TDD powinna w przyszłości o wiele łatwiej poddawać się zmianom i być prostsza w utrzy- maniu. TDD to przede wszystkim metodologia wytwarzania oprogramowania. Postulowane przez nią testy automatyczne dają programiście pewność co do jakości i funkcjonalności kodu, ale nie mogą zostać uznane za wystarczające narzędzie testujące. Zwłaszcza wartość testów pisanych przez programistę jest ograniczona przez jego pojmowanie problemu. Innymi słowy, programista napisze testy jednostkowe jedynie dla sytuacji, które jest w stanie przewidzieć. W celu sprawdzenia rzeczywistej wartości oprogramowania należy przeprowadzić dodat- kową rundę ręcznych lub automatycznych testów akceptacyjnych. Rozdział 7. (cid:81) Narzędzia do testowania 207 Pokrycie całości Ocena jakości testów jednostkowych jest nierozerwalnie związana z odpowiedzią na pytanie, czy testy sprawdzają całość kodu aplikacji. Wprowadzono nawet specjalne pojęcie stopnia pokrycia (ang. code coverage). Wskazuje on procent kodu aplikacji, który jest uruchamiany podczas testowania. Można go wyznaczać w oparciu o liczbę linii kodu bądź liczbę rozga- łęzień w kodzie. Niezależnie od tego, na co się zdecydujemy, najważniejsze jest to, że na- szym dążymy do pokrycia testami 100 procent aplikacji Rails (sam rozpocząłem próby osiągnięcia tych 100 procent na dwa sposoby: poprzez 100-procentowe pokrycie modeli samymi testami jednostkowymi oraz 100-procentowe pokrycie całej aplikacji kompletnym zestawem testów). Szczegóły wyliczania stopnia pokrycia nie są aż tak istotne. Oczywiście samo pokrycie nie zapewnia jakości testów. Ktoś mógłby stworzyć testy, pod- czas których uruchamiany jest każdy skrawek aplikacji, ale nie jest przeprowadzana żadna asercja. W takim wypadku testy sprawdzałyby jedynie, czy program działa bez „wywrotek” (co w niektórych wypadkach okazuje się całkowicie poprawnym testem). Brak pokrycia prawie zawsze oznacza kłopoty — części aplikacji, do których nie ma testów często zawie- rają problematyczny kod. Jeśli jednak wiemy, że osoby piszące testy do naszej aplikacji tworzą je regularnie i kompetentnie, wówczas stopień pokrycia kodu może służyć za przy- zwoity wyznacznik jakości testów. Instalacja rcov rcov to standardowe narzędzie do mierzenia stopnia pokrycia testami aplikacji Rails. Nie jest wbudowane w Rails, ale można zainstalować je na dwa sposoby. Osoby, które nie mają dostępu do kompilatora C, mogą zainstalować rcov jako gem Ruby: $ gem install rcov Podobnie jak w przypadku innych gemów być może trzeba będzie wybrać osobną wersję przeznaczoną dla aktualnie używanego systemu operacyjnego. Jeśli programista ma dostęp do kompilatora C (czyli, ogólnie rzecz biorąc, korzysta z dowol- nej poważnej dystrybucji Linuksa, z Mac OS X z zainstalowanym Xcode lub z Windows z darmowym kompilatorem konsolowym), powinien zainstalować rcov w wersji natywnego rozszerzenia. Twórcy narzędzia zapewniają, że w tej postaci będzie ono działało dwa razy szybciej, co z pewnością równoważy koszt wpisania dodatkowego polecenia. Przed instalacją należy pobrać spakowany plik ze strony http://eigenclass.org/hiki.rb?rcov i rozpakować go do nowego katalogu. Z wnętrza tego katalogu należy następnie wydać po- lecenie setup: $ ruby setup.rb Dla osób, które pracują w systemie Windows pozbawionym kompilatora, możliwe jest jesz- cze pobranie z tej samej strony prekompilowanego rozszerzenia dla jednej ze standardowych dystrybucji Ruby. Na stronie znajduje się instrukcja instalacji. 208 Ruby on Rails. Zaawansowane programowanie W celu integracji rcov z Rails konieczna jest instalacja pluginu rails_rcov: $ ruby ./script/plugin install –x http://svn.codahale.com/rails_rcov Jeśli ktoś nie chce korzystać z Subversion, może jak zwykle pominąć opcję –x. Ten akurat plugin zawiera wyłącznie pojedynczy plik Rake, zatem Subversion na wiele się nie przyda. Jak korzystać z rcov w Rails? Plugin rails_rcov rozszerza nasz repertuar o kilka nowych zadań Rake. Dla każdego typu testów (jednostkowych, funkcjonalnych i integracyjnych) plugin dodaje zadanie rcov, tworzące dane rcov, oraz zadanie clobber, które czyści te dane. Nazwy nowych zadań są rozszerze- niami nazw istniejących typów testów, zatem mamy na przykład zadania test:units:rcov lub test:units:clobber. Wymienione zadania Rake są przydatne, jednak nie są kompletne. Każde z nich uruchamia odpowiedni typ testów i tworzy raport pokrycia, którego najważniejsze elementy są wysy- łane na standardowe wyjście. Wyjście plikowe jest zapisywane w katalogu główny katalog Rails /coverage. Warto nakazać Subversion ignorowanie plików w tym katalogu, ponieważ nie ma sensu wgrywanie ich do repozytorium (aby Subversion nie wykrywał plików, trzeba będzie najpierw dodać sam katalog). Informacja o pokryciu aplikacji testami funkcjonalnymi jest oczywiście ciekawa, jednak chcemy również wiedzieć, w jakim stopniu wszystkie testy pokrywają aplikację. Niestety, nie istnieje standardowe zadanie gromadzące te dane w jednym miejscu (w dokumentacji pluginu znajduje się informacja, że takie zadanie istnieje, ale to kłamstwo — a przynajm- niej było to kłamstwo, kiedy ostatni raz sprawdzałem). Oczywiście samodzielne skonstru- owanie takiego zadania nie jest przesadnie trudne. Poniższy przykład poprawia wersję przed- stawioną na stronie rcov. Należy umieścić kod w pliku lib/tasks/coverage.rake: require rcov/rcovtask namespace :test do namespace :coverage do desc Usuwa łączne dane na temat pokrycia. task(:clean) do rm_rf data/coverage rm_f data/coverage.data end end test_types = w[unit functional integration] desc Łączy dane na temat pokrycia kodu testami jednostkowymi, (cid:180)funkcjonalnymi i integracyjnymi task :coverage = test:coverage:clean tests_to_run = test_types.select do |type| FileList[ test/#{type}/**/*_test.rb ].size 0 end tests_to_run.each do |target| namespace :coverage do Rozdział 7. (cid:81) Narzędzia do testowania 209 Rcov::RcovTask.new(target) do |t| t.libs test t.test_files = FileList[ test/#{target}/**/*_test.rb ] t.verbose = true t.rcov_opts --rails --aggregate data/coverage.data if target == tests_to_run[-1] t.output_dir = data/coverage else t.rcov_opts --no-html end end end task :coverage = test:coverage:#{target} end end W pliku znajdują się dwa zadania — test:coverage_clean i test:coverage — które w progra- mistyczny sposób tworzą zadania rcov, umieszczając ostateczny wynik w katalogu coverage/ (cid:180)complete. Najważniejsze są tutaj opcje –-aggregate i –-no-html. Pierwsza z nich sprawia, że plik coverage.data będzie zawierał wspólne dane wygenerowane przez osobne zadania (działanie rcov będzie nieco spowolnione, dlatego naprawdę warto zainstalować natywne rozszerzenie). W normalnych okolicznościach doprowadziłoby to do sytuacji, w której dane każdego zadania są łączone z danymi wszystkich wykonanych wcześniej zadań. Ponieważ nie wydaje się to szczególnie przydatne, we wszystkich testach z wyjątkiem końcowego, który jest zapisywany w coverage/complete, używam opcji –-no-html. Zadanie test:coverage uruchamia wszystkie trzy zestawy testów jednostkowych, które mają dwa rodzaje wyjścia: ich normalne wyjście oraz tekstowy przegląd danych. Przy oka- zji powstaje bardzo wiele plików HTML. Przyjrzyjmy się najpierw plikowi index.html. Powinien on wyglądać mniej więcej tak jak zawartość rysunku 7.1. Rysunek 7.1 210 Ruby on Rails. Zaawansowane programowanie Plik zawiera listę wszystkich plików źródłowych projektu Rails. Dla każdego pliku podano liczbę linii w ogóle i liczbę linii kodu. Różnica polega na tym, że wartość przedstawiona w kolumnie Total została obliczona z uwzględnieniem komentarzy, a także linii def i end, podczas gdy kolumna Lines of code zawiera tylko wykonywalne linie. W oparciu o te war- tości wyliczony został odsetek linii, które zostały chociaż raz wykonane podczas testów. rcov może także podać informację na temat tego, ile razy wykonano daną linię, jednak w tej chwili nie jest to nam specjalnie potrzebne. Pliki, które nie zostały uruchomione podczas testów, nie pojawiają się na liście, dlatego należy sprawdzić, czy widać tam wszystkie ocze- kiwane pliki. Każdy wiersz tabeli opisuje jeden plik. Nazwy plików są linkami prowadzącymi do bardziej szczegółowych informacji na temat pokrycia. Na rysunku 7.2 widać fragment pliku ingredients_ (cid:180)controller.rb, w którym oznaczono jeden z segmentów niepokrytych testami. Rysunek 7.2 Nie jestem pewien, na ile wyraźnie widać to w odcieniach szarości, ale klauzula else została podświetlona na czerwono, co znaczy, że ta gałąź kodu nie została przetestowana. W celu pozyskania tego typu danych rcov przeprowadza bardzo zaawansowaną analizę wyjścia z interpretera Rails, jednak czasami popełnia błędy. Widać to także w naszym przykładzie: przez to, że bloki wewnętrzne respond_to znalazły się w jednej linii, rcov nie jest w stanie wykryć, że nie istnieje test generowania XML przez tę metodę. Dość dziwne jest również to, że linie zawierające end — zarówno te kończące blok, jak i te kończące metodę — zostały oznaczone jako niepokryte. Być może nie ma to po prostu znaczenia. Naszym celem powinno być każdorazowe osiąganie wartości 100 procent pokrycia. W Rails jest to możliwe również dzięki elastyczności języka Ruby. Jeśli osiągniemy wartość 100 pro- cent, a testy są napisane rozsądnie, możemy uznać, że jesteśmy bezpieczni podczas dodawa- nia, naprawiania i refaktoryzacji kodu. Za pomocą pojedynczego uruchomienia testów możemy upewnić się, że nasze zmiany nie doprowadziły do powstania nowych błędów. Jak widać na rysunku 7.1, który przedstawia stan aplikacji Zupy OnLine podczas pisania wstępnej wersji tego rozdziału, projekt jest bardzo blisko 100-procentowego pokrycia kodu testami. Do osiągnięcia tego wyniku wystarczyło automatyczne wygenerowanie kodu przez Rails oraz omówione wcześniej praktyki TDD. Jedynym poważnym brakiem jest obiekt pośredniczący, który został przedstawiony jako możliwa opcja w rozdziale 6. W swojej aktualnej postaci kod nie wywołuje bazowej klasy pośrednika, dlatego nie jest ona uruchamia- na podczas testów. W tej chwili nie jest to dla nas żadnym problemem, natomiast w przypad- ku prawdziwej aplikacji trzeba by się zastanowić nad wyeliminowaniem nieużywanego kodu. Rozdział 7. (cid:81) Narzędzia do testowania 211 Większość niepokrytych przypadków to niepowodzenia różnych metod tworzących i uak- tualniających obiekty, co również widać na rysunku. Najwyraźniej zapomniałem również napisać testy kontrolera dla ajaksowych formularzy edycji tagów. By przetestować niepo- wodzenie zapisu danych, należałoby stworzyć scenariusz testowy, w którym nie zapis nie byłby możliwy. Najprostszy sposób to próba zachowania obiektu, który nie przejdzie wali- dacji Rails lub złamie ograniczenia bazy danych. Jest tylko jeden problem. W obecnej chwili Recipe nie posiada żadnych ograniczeń bazoda- nowych ani walidacji Rails. Chociaż mógłbym podać przynajmniej dwa odpowiednie przy- kłady obiektów (lub zrobić coś naprawdę dziwnego i podjąć próbę zapisu tytułu o długości 10 000 znaków), wydaje się, że musi istnieć prostszy sposób. Otóż istnieje. Testowanie za pomocą atrap Testowanie za pomocą atrap (ang. mock testing) polega na wykorzystaniu „udawanych” obiektów, które zastępują te prawdziwe podczas testów automatycznych. Pierwotnie tech- nika ta była stosowana podczas testowania systemów wymagających baz danych, połączenia z siecią lub innych zasobów, które trudno wiarygodnie skonfigurować w środowisku testowym. Obecnie stosuje się ją także w celu sprawdzenia poprawności działania programów i w celu lepszej orientacji testów. Testy za pomocą atrap są jedną z tych dziedzin, w których każdy zestaw narzędzi wprowa- dza strukturę nazw odmienną od pozostałych. Zamierzam oprzeć się na konwencji postu- lowanej przez Martina Fowlera w artykule Mocks Aren’t Stubs o różnicy pomiędzy obiek- tami mock a innym typem obiektów o nazwie stub (szczegóły w sekcji „Źródła” na końcu rozdziału). Jedne i drugie są dublerami prawdziwych obiektów w sposób analogiczny do tego, w jaki kaskaderzy zastępują aktorów podczas niebezpiecznych ujęć. Stub to „udawany” obiekt lub metoda, które podczas testów zwracają ustaloną wartość bez dokonywania rze- czywistych obliczeń. Mock (atrapa) także zwraca ustaloną wartość, jednak powinna posiadać dodatkową funkcjonalność śledzenia wywołań do obiektu oraz, co ważniejsze, powinna sprawdzać, czy wywołania te są zgodne z oczekiwaniami określonymi podczas tworzenia testu. Jedną ze wspaniałych cech testów za pomocą atrap w Rails jest to, że narzędzia do tworze- nia takich testów potrafią wykorzystać szerokie możliwości metaprogramowania w Rails do zamiany istniejących obiektów i klas w obiekty stub lub mock. Odróżnia to Rails od, na przy- kład, Javy, gdzie narzędzia do tworzenia atrap za pomocą interfejsów i ładowania klas pro- dukują obiekty, które zastępują te oryginalne, lecz różnią się od nich w ryzykowny sposób. Jako że tworzenie „udawanych” obiektów w Ruby jest bardzo proste, zyskujemy nowe moż- liwości testowania. Przykładem dobrym i na czasie może być stworzenie modelu ActiveRecord, który zachowuje się dokładnie tak jak każdy inny model ActiveRecord w systemie z tą róż- nicą, że wychwytuje próby zapisu do bazy danych i zwraca określoną wartość bez łączenia się z bazą. 212 Ruby on Rails. Zaawansowane programowanie FlexMock Istnieją trzy lub cztery różne pakiety Rails, które umożliwiają przeprowadzanie testów za pomocą atrap. Możliwości pakietów są zbliżone, dlatego omówię tylko jeden z nich — FlexMock. Został on napisany przez Jima Weiricha (który jest także osobą odpowiedzialną za Rake). FlexMock jest dostępny w postaci gema Ruby, czyli instalujemy go za pomocą standardowego polecenia gem: $ sudo1 gem install flexmock By testy mogły korzystać z FlexMock, konieczne jest dodanie linii require na początku każdego skryptu testowego, który będzie używał atrap (a jeśli będą one wykorzystywane często, linię warto dodać do test_helper.rb): require flexmock/test_unit Pora zacząć udawanie. Zamierzam przedstawić konkretny test, który stworzyłem w celu dotarcia do wcześniej nie- pokrytej części kodu, a następnie opowiedzieć, jak można rozszerzyć ten test i jak stworzyć inne obiekty mock i stub. Zajmiemy się niepokrytą klauzulą else z pliku recipes_controller.rb: def update @recipe = Recipe.find(params[:id]) respond_to do |format| if @recipe.update_attributes(params[:recipe]) flash[:notice] = Uaktualniono przepis. format.html { redirect_to(@recipe) } format.xml { head :ok } else format.html { render :action = edit } format.xml { render :xml = @recipe.errors, :status = :unprocessable_entity } end end end Niepokryta część kodu zostanie osiągnięta, jeśli update_attributes zakończy się niepowo- dzeniem. Jak już wspomniałem, stworzenie obiektu, którego nie da się zapisać, nie jest takie proste, ponieważ klasa Recipe nie jest w żaden sposób walidowana. Zamiast tracić czas, łamiąc sobie głowę nad tym zadaniem, możemy zmusić system do błędu zapisu. Poniższy kod należy umieścić w pliku test/fixture/recipes_controller_test.rb: def test_should_fail_update flexmock(Recipe).new_instances.should_receive(:update_attributes). (cid:180)at_most.once.and_return(false) put :update, :id = 1, :recipe = {:title = Rosołek babci } assert_template( edit ) actual = Recipe.find(1) assert_not_equal( Rosołek babci , actual.title) assert_equal( 1 , actual.servings) end 1 sudo, oczywiście, dotyczy tylko pewnych odmian Linuksa i Mac OS X — przyp. tłum. Rozdział 7. (cid:81) Narzędzia do testowania 213 Najważniejsza jest pierwsza linia. Przeanalizujmy ją po kawałku: (cid:81) flexmock(Recipe) — tworzy nowy obiekt zastępczy (tym razem jest on typu stub). Metoda flexmock pobiera wiele różnych opcji, do których przejdę za moment. W tym wypadku jest wywoływana z argumentem będącym obiektem Ruby z krwi i kości, czyli z klasą Recipe. Chodzi nam o osiągnięcie omówionych wcześniej funkcjonalności atrapy wokół istniejącego obiektu. (cid:81) new_instances — jest to metoda pośrednika obiektu-atrapy. Działa tylko wtedy, gdy obiekt, którego atrapę tworzymy, jest obiektem klasy. Po wywołaniu tej metody FlexMock zastosuje podaną specyfikację do wszystkich instancji klasy, czyli zmieni zachowanie wywołań new. W rezultacie każdy obiekt ActiveRecord przepisu zostanie rozszerzony o zachowanie atrapy. Oznacza to, że obiekty już istniejące i przechowywane jako dane do testów nie zostaną obdarzone tym zachowaniem, ale te same obiekty na nowo załadowane z bazy do modeli ActiveRecord — już tak. Wywołanie tej metody, podobnie jak większości innych metod we FlexMock, zwraca specjalny obiekt, który zapamiętuje różne oczekiwania, by móc stworzyć łańcuch ograniczeń taki jak w przykładzie. (cid:81) should_receive(:update_attributes) — tutaj zaczynamy określać zachowanie obiektów stub. Wywołanie tej metody informuje FlexMock o tym, że będziemy chcieli zrobić coś z wywołaniem update_attributes, ale nie określa jeszcze konkretnego zachowania. Metoda should_receive może pobrać dowolną liczbę argumentów w postaci symboli, z których każdy reprezentuje metodę, która będzie zastępowana zgodnie z tą samą specyfikacją. (cid:81) and_return(:false) — tą linią kończymy określanie zachowania. FlexMock zwróci wartość false dla każdego wywołania update_attributes, bez odwoływania się do bazy danych ani wykonywania żadnych innych zbędnych operacji. Metoda ta jest bardzo elastyczna. Można przekazać jej kilka wartości — wówczas będzie je zwracała jedną po drugiej podczas kolejnych wywołań. Jeśli klas będzie więcej niż wartości, zwrócone zostaną ponownie wartości z początku listy. Można jeszcze przekazać blok pobierający wszystkie argumenty dublowanej metody, na których można wykonać dowolne operacje obliczające zwracaną wartość. Test kończy się sukcesem, ponieważ został dodany w celu zwiększenia pokrycia i koncentruje się na określonej gałęzi kodu
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Ruby on Rails. Zaawansowane programowanie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: