Backbone.js Testing:

Although this book assumes a comfortable level of familiarity with Backbone.js, Underscore.js, and jQuery, we will briefly touch upon the basics of Backbone.js application development.

Backbone.js provides abstractions and useful functionality for architecting and developing JavaScript web applications. Backbone.js brings order to the chaotic interactions between program and display logic, DOM events, and backend communication. This is achieved via what could loosely be considered a Model-View-Controller (MVC) paradigm that separates application code into the following topics:

Devising and implementing a test plan is fundamentally a practical exercise, and we can better achieve our goal of overall application reliability by applying test lessons and techniques to a real application—whether it is one that has just been started or an existing application in need of better test coverage.

If you already have a Backbone.js application in development, you can most likely skip to the next section of this chapter. One potential issue we want to identify is the complexity of the existing application, especially one with minimal or no existing tests. Complicated dependencies, non-modular design, and highly coupled application components may require extensive mocking and stubbing to even permit a base level of test framework integration. Ultimately, the test infrastructure written around a legacy application will likely be quite different from the one written around a modular, decoupled application such as Notes. Accordingly, you...

There are numerous competing and complementary theories regarding software testing and development methodologies. Reading up on the world of test methods provides an excellent background for any developer looking to improve the ways in which they construct, implement, and manage tests. For brevity's sake, we will only introduce two paradigms in this book that are particularly useful for Backbone.js testing—Test-Driven Development (TDD) and Behavior-Driven Development (BDD).

Test-Driven Development is a process wherein tests are written first and then the actual code is written. The benefits of this approach include:

TDD and general software testing principles are covered in many resources; a recommended reference on the subject is Growing Object-Oriented Software...

Before jumping into the testing waters, it makes sense to have a plan of what we should test and why. The term test plan is heavily overloaded with many potential interpretations as processes, literature, and practices have been prevalent and continuously evolving for decades. It is not surprising that modern test plans can range from casual, mostly ad-hoc practices to formal, 100-page documents requiring executive sign offs at various stages.

As Backbone.js applications are typically created in iterative development cycles, often without a lot of extra formality, we will take a fairly practical approach and create a test plan that simply identifies testing categories and applies them to the application under test...

Backbone.js applications are quite amenable to testing separation. Backbone.js provides a small number of core components that mostly avoid interdependencies. Our goal in this section is to identify the different parts of a Backbone.js application that can be unit tested in isolation and start thinking about the features of each one that we should test. Many components can simply be instantiated alone while others will need some extra mocking or patching help in our tests.

A Backbone.js application is used as a cohesive whole by end users, and wherever possible, we should have the test infrastructure verify overall application functionality and behaviors that cut across single Backbone.js components.

Now that we can identify the aspects of the Backbone.js components that we want to test, let's begin planning and writing tests for the namespace utility and the Backbone.js model. For each component, we will examine application use cases and expected behaviors and then write tests to verify our expectations.

// Class names.
var App = App   || {};
App.Config      || (App.Config = {});
App.Models      || (App.Models = {});
App.Collections || (App.Collections = {});
App.Routers     || (App.Routers = {});
App.Views       || (App.Views = {});
App.Templates   || (App.Templates = {});

// Application instance.
var app = app || {};

With our Backbone.js application files and the preliminary application tests ready, we need to integrate everything into the test driver we created in Chapter 1, Setting Up a Test Infrastructure. We will continue with the existing application directory structure by adding specs to chapters/02/test/js/spec and copying the application libraries from notes/app/js/app to chapters/02/app/js/app.

In this chapter, we reviewed the basics of Backbone.js applications and introduced the Notes application as a helpful, if optional, companion to the test examples in this book. We then reviewed some relevant high-level testing concepts and dived into the specifics of what we will want to test in a Backbone.js application—in separated application pieces and as integrated parts of a whole. Finally, we wrote our first application unit tests and extended the test infrastructure from Chapter 1, Setting Up a Test Infrastructure, to execute our test reporter.

You should now be able to take an existing or in-development Backbone.js application, analyze its components, and create an abstract test infrastructure outline that will later be filled in with actual tests and suites.

In the next chapter, we will learn about Chai assertions, basic Mocha test constructs (specs and suites), test setup/teardown/configuration, and how to deterministically verify behavior in an asynchronous application...