Acknowledgements .................................................................................................................. xiv 1. Introduction ........................................................................................................................... 1 1.1. Why test? .................................................................................................................... 1 1.2. Why should I change my code? ................................................................................... 2 1.3. What is this book not about? ....................................................................................... 3 1.4. How the book is structured .......................................................................................... 4 1.5. Coding conventions ..................................................................................................... 4 1.6. Example code ............................................................................................................. 6 2. Building blocks ...................................................................................................................... 8 2.1. What is an automated test suite? .................................................................................. 8 2.2. Testing frameworks ..................................................................................................... 9 2.3. Hello, world! ............................................................................................................... 9 2.4. Assertions ................................................................................................................. 11 2.4.1. The Node module ................................................................................ 12 2.4.2. Jasmine matchers ............................................................................................ 13 2.4.3. Chai assertion chains ....................................................................................... 13 2.4.4. QUnit assertions ............................................................................................. 14 2.4.5. assertions and matchers ....................................................................... 15 2.4.6. Other types of assertions ................................................................................. 16 2.5. Organising tests ......................................................................................................... 17 2.5.1. Setting up with blocks ...................................................................... 18 2.5.2. Wrapping up with blocks ................................................................... 19 2.5.3. Contexts with blocks .................................................................... 20 2.6. Stubs, mocks and spies .............................................................................................. 22 2.6.1. Enter stubs ..................................................................................................... 24 2.6.2. Pattern-matching arguments ............................................................................. 25 2.6.3. Testing interactions with mocks ....................................................................... 27 2.6.4. Checking your wiring with spies ...................................................................... 28 2.7. Asynchronous tests .................................................................................................... 28 2.7.1. The error-first callback convention ................................................................... 30 2.7.2. Multi-step async tests ...................................................................................... 31 2.7.3. Sequencing functions with Async .................................................................... 33 2.7.4. Generating steps with continuables .................................................................. 34 2.7.5. Async stories with ............................................................................... 36 3. Events and streams ............................................................................................................... 37 3.1. Event emitters ........................................................................................................... 37 3.1.1. Black-box testing ............................................................................................ 38 3.1.2. Mock-based testing ......................................................................................... 40 3.1.3. Cutting out the listener .................................................................................... 41 3.1.4. Spy-based testing ............................................................................................ 44 3.2. Event listeners ........................................................................................................... 44 3.2.1. Decoupling listeners from actions .................................................................... 45 3.2.2. Decoupling and framework patterns ................................................................. 47 3.3. Pitfalls of event testing .............................................................................................. 48 3.3.1. Events as a public interface ............................................................................. 50 3.3.2. Selective integration testing ............................................................................. 50 3.3.3. Changing your API design .............................................................................. 51 3.4. Streams ..................................................................................................................... 54 3.4.1. Building a data source ..................................................................................... 55 3.4.2. Checking a readable stream’s output ................................................................ 56 iii JavaScript Testing Recipes 3.4.3. Testing a transform stream .............................................................................. 57 3.4.4. Making your own transforms ........................................................................... 58 3.4.5. Decoupled streams .......................................................................................... 60 4. Browser applications ............................................................................................................ 64 4.1. Form validation ......................................................................................................... 64 4.1.1. Extracting user interface logic ......................................................................... 66 4.1.2. Extracting markup for tests .............................................................................. 66 4.1.3. Separating business logic from the user interface .............................................. 69 4.1.4. Testing user interface logic .............................................................................. 71 4.1.5. Simulating user input ...................................................................................... 74 4.2. Modular interfaces ..................................................................................................... 75 4.2.1. Directly communicating components ................................................................ 77 4.2.2. Dependency injection ...................................................................................... 80 4.2.3. Introducing a model ........................................................................................ 81 4.2.4. Building and testing the model ........................................................................ 87 4.2.5. Using frameworks ........................................................................................... 90 4.3. Talking to the server .................................................................................................. 90 4.3.1. with callbacks ......................................................................... 92 4.3.2. with promises ......................................................................... 96 4.3.3. shorthand ................................................................................ 99 4.3.4. Using a fake server ......................................................................................... 99 4.3.5. WebSocket and other protocols ...................................................................... 102 4.4. Storing data ............................................................................................................. 103 4.4.1. Black-box testing .......................................................................................... 104 4.4.2. Testing persistence contracts .......................................................................... 106 4.4.3. Mocking database interactions ....................................................................... 107 4.5. , and routers .............................................................................. 109 4.5.1. Testing changes ............................................................................. 110 4.5.2. Testing and routers ....................................................................... 112 4.6. Using the timer functions ......................................................................................... 114 4.7. Working with build tools