Continuous Testing: with Ruby, Rails, and JavaScript

by Ben Rady, Rod Coffin

We all know feedback is good. Why not get it instantly? Continuous Testing with Ruby shows you how to use a combination of tests, tools, and techniques to immediately detect problems in code. This book will help you create a personalized development environment that instantly validates your decisions as you make changes to your code. This rapid feedback allows you to focus on the problem at hand, rather than constantly re-checking prior work. If you want to spend more of your time writing valuable software, and less time slogging through code line-by-line in a debugger, Continuous Testing with Ruby can help you!

Continuous Testing (CT) is a developer practice that shortens the feedback loops established by test-driven development and continuous integration. Building on techniques used by Agile software development practitioners, Continuous Testing with Ruby shows you how to get instant feedback about both the quality of your code, and the quality of your tests.

We show how you can create a customized continuous testing environment, specifically suited to the projects you're working on. You'll see working examples for languages such as Ruby and JavaScript, but the techniques described in this book can easily be applied no matter what technology you happen to be working with. We also cover how to extend this environment when working with frameworks such as Ruby on Rails, and discuss how creating rapid feedback loops can dramatically increase the rate at which you can deliver working, valuable software.

Automated testing is an increasingly common practice in the software development industry. However, many companies struggle to gain all the benefits of automated testing, due to poorly written or incomplete tests. Continuous Testing with Ruby shows how these companies can get the most value out of their existing tests. It also helps you improve the quality of the new tests you write, by giving you instant feedback about problem areas, and creating a visceral feedback loop for test quality that you can actually feel as you work.

Just as continuous integration and test-driven development have changed the definition of software development in the last ten years, Continuous Testing is poised to become a standard practice for development teams in the next decade.

Genres: Programming, Technical

160 pages, Paperback

First published February 15, 2011

Reviews

[Anton Antonov · Rating 3 out of 5]

Do you want to write FIRE tests? Tests that are lit? Well, maybe not lit, but “Fast, Informative, Reliable, Exhaustive” — ergo, FIRE, for sure.

Complemented by Better Specs, which remains a valid resource to this day, “Continuous Testing” is a really light and fast read. Its goal is to provide end-to-end testing for all the common aspects of a Rails application that also serves the front-end.

It does the job well, and at the time, it was a really nice, creative read for me to explore patterns and ideas for testing a Rails monolith.

Nota bene, this book is dated. Nowadays, try to find a more up-to-date book. It is closely coupled to the technological reality of 2015-2016, at least when I read and applied ideas from it.

[Fotis Koutoulakis · Rating 3 out of 5]

By now very dated in terms of the code examples (and some stuff like `Autotest` having left the `Zentest` repo and being their own thing, or Firebug no longer existing, plus having tools like Fable, Clojurescript and Typescript to patch up Javascript's holes - some of which have already been fixed to my understanding).

But some of the principles in the book are very solid and gel well with another book I'm reading at the moment on Continuous Delivery and Integration.

[Augusto · Rating 5 out of 5]

Another sweet, short and pragmatic book from The Pragmatic Programmers.

This book covers 'how' to do Continuous Testing with Ruby, Rails and Javascript (exactly as the title promotes), in a way that it's very easy to take to other technologies.

The authors describe how to build a Continuous Testing (CT) environment using certain tools, which might become outdated soon (such as autotest), but they explain the core idea a few times: Use library/framework X to get notified of filesystem changes, then run associated tests. It's so simple that there are no real reasons why not to implement this.

I really enjoyed the approach to learn how a technology works on chapter 4. I've been using tests to understand how a technology works for a while, but the the authors approach is definitely an improvement to the way I usually did it. I liked the idea of adding code to the test and then refactoring it to the production code. It reminded me a bit about Keith Braithwaite's workshop TDD as if you meant it. Gojko Adzic describes the main exercise of the workshop on his blog.

[Graham · Rating 4 out of 5]

A good read on tightening the feedback loop of development further than continuous integration. Most developers, or at least most I have worked with, run their unit tests at least once before they commit their code to source control. Ben takes the idea of tight feedback loops to the next logical step, by running unit tests on every save (obviously compile also if applicable for that language). This simple technique lets the developer know even earlier if their changes had adverse effects. The second technique shown was to checkout the latest code every time all the tests pass. This decreases the time between integrations. The book mainly concentrates on Ruby/Rails and JavaScript but the concepts are applicable in any language. Hopefully this technique becomes mainstream and becomes the default in popular IDEs.

[Johnny · Rating 2 out of 5]

Years passed by since I read “Continuous Testing” the first time. Books on techniques and practices most often have a way longer timespan in which they are useful than books on a specific technology. In this book it’s a bit different. Too much is based on tools that are now no longer used or have a completely different syntax.

While the idea of running your tests continuously is still valid, you constantly see code samples that no longer work. The theoretical part of the book is unfortunately split around all the different chapters and depends heavily on the specific tools. Is the tool gone your chapter falls apart.

I therefore no longer can recommend to read this book.

[Jason Stirk · Rating 4 out of 5]

I read the beta eBook. Even in it's unpolished state, there is heaps of useful information here.

Some of the highlights are :
* Tips and tricks on ensuring you maintain a fast and reliable test suite;
* Tricks to make sure your existing tools are running as fast as they can;
* Tools and techniques to augment or replace your existing test tools, so as that you can get a more complete picture of your project than just your specs passing.

I can't wait for the book to be complete so as that I can have another read.

[Sergey Shishkin · Rating 4 out of 5]

This is a great book teaching you not only the tools, but rather the whole mindset of continuous testing. It goes far beyond unit and integration testing to shortening the feedback loop by automating any type of validation. The ease of the described techniques can even sometimes be mistaken with cheating or magic.
I think the authors could elaborate on testing JavaScript browser application a little more. Nonetheless this is a great book I would recommend to every developer regardless of language or platform.

[Gyuri · Rating 5 out of 5]

I read the finished book, early after it went out from beta. The book helped me to understand how simple CT can be. Although I could not try out js ct yet, thus it is clear that none of the techniques is a mystery for me anymore.

[Harry Yeh · Rating 4 out of 5]

Great book on getting started with Continuous Testing and Integration with Ruby, Ruby on Rails and Node.js. Talks about the use of RSPEC and Autotest amongst other things. I used this book with Ubuntu 12.04 LTS