You are previewing Testable JavaScript.

Testable JavaScript

Cover of Testable JavaScript by Mark Ethan Trostler Published by O'Reilly Media, Inc.
  1. Testable JavaScript
  2. Dedication
  3. Preface
    1. The Goal of This Book
    2. Who This Book Is For
    3. Who This Book Is Not For
    4. Who I Am
    5. What You Will Learn from This Book
      1. Content
    6. If You Like (or Don’t Like) This Book
    7. Recap
    8. How to Contact Us
    9. Conventions Used in This Book
    10. Using Code Examples
    11. Safari® Books Online
    12. Thanks!
  4. 1. Testable JavaScript
    1. Prior Art
      1. Agile Development
      2. Test-Driven Development
      3. Behavior-Driven Development
      4. The Best Approach?
    2. Code Is for People
      1. Why
      2. What
      3. How
    3. Beyond Application Code
      1. Testing
      2. Debugging
    4. Recap
  5. 2. Complexity
    1. Code Size
    2. JSLint
    3. Cyclomatic Complexity
    4. Reuse
    5. Fan-Out
    6. Fan-In
    7. Coupling
      1. Content Coupling
      2. Common Coupling
      3. Control Coupling
      4. Stamp Coupling
      5. Data Coupling
      6. No Coupling
      7. Instantiation
    8. Coupling Metrics
    9. Coupling in the Real World
      1. Testing Coupled Code
    10. Dependency Injection
    11. Comments
      1. YUIDoc
      2. JSDoc
      3. Docco/Rocco
    12. The Human Test
    13. Recap
  6. 3. Event-Based Architectures
    1. The Benefits of Event-Based Programming
    2. The Event Hub
      1. Using the Event Hub
      2. Responses to Thrown Events
      3. Event-Based Architectures and MVC Approaches
      4. Event-Based Architectures and Object-Oriented Programming
      5. Event-Based Architectures and Software as a Service
    3. Web-Based Applications
    4. Testing Event-Based Architectures
    5. Caveats to Event-Based Architectures
      1. Scalability
      2. Broadcasting
      3. Runtime Checking
      4. Security
      5. State
    6. A Smarter Hub: The Event Switch
      1. Deployment
      2. An Implementation
      3. Sessions
      4. Extensibility
    7. Recap
  7. 4. Unit Tests
    1. A Framework
    2. Let’s Get Clean
    3. Writing Good Tests
      1. Isolation
      2. Scope
      3. Defining Your Functions
      4. Positive Testing
      5. Negative Testing
      6. Code Coverage
    4. Real-World Testing
      1. Dependencies
      2. Asynchronous Testing
    5. Running Tests: Client-Side JavaScript
      1. PhantomJS
      2. Selenium
    6. Running Tests: Server-Side JavaScript
      1. Jasmine
    7. Recap
  8. 5. Code Coverage
    1. Coverage Basics
    2. Code Coverage Data
    3. A Hands-on Example
      1. Instrumenting Files
      2. Anatomy of a Coveraged File
    4. Exercise/Deploy
      1. Client-Side JavaScript
      2. Server-Side JavaScript
    5. Persisting Coverage Information
      1. Unit Tests
      2. Integration Tests
    6. Generating Output
    7. Aggregation
    8. Hidden Files
    9. Coverage Goals
    10. Recap
  9. 6. Integration, Performance, and Load Testing
    1. Integration Testing
      1. Selenium
      2. CasperJS
    2. Performance Testing
      1. Generating HAR Files
      2. Viewing HAR Files
      3. Browser Performance Testing
    3. Load Testing
      1. Browser Load Testing
    4. Tracking Resource Usage
      1. Client-Side Tracking
      2. Server-Side Tracking
    5. Recap
  10. 7. Debugging
    1. In-Browser Debugging
      1. Firefox
      2. Chrome
      3. Safari
      4. Internet Explorer
    2. Node.js Debugging
    3. Remote Debugging
      1. Chrome
      2. PhantomJS
      3. Firefox
    4. Mobile Debugging
      1. Android 4
      2. iOS 6
      3. Adobe Edge Inspect
      4. Other Mobile Debugging Options
    5. Production Debugging
      1. Minified Code
      2. Source Maps
    6. Recap
  11. 8. Automation
    1. What to Automate
    2. When to Automate
    3. How to Automate
      1. Automating with Continuous Integration
      2. Automating the Development Environment
      3. Automating the Build Environment
      4. Deployment
    4. Recap
  12. Index
  13. About the Author
  14. Colophon
  15. Copyright
O'Reilly logo

Chapter 2. Complexity

Complex: bad. Simple: good. We touched on this already, and it’s still true. We can measure complexity with some accuracy via static analysis. Measures such as JSLint, cyclomatic complexity, lines of code, and fan-in and fan-out are important. However, nothing measures complexity as accurately as showing your code to a coworker or colleague.

Code can be complex for a number of reasons, from the serious “this is a hairy algorithm” to the mundane “a JavaScript newbie wrote it and it’s nasty,” and everything in between. Analyzing the complexity of static code is a great starting point toward creating testable JavaScript.

Maintainable JavaScript is clear, consistent, and standards-based. Testable JavaScript is loosely coupled, short, and isolatable. The magic happens when your code is both maintainable and testable. Since you will spend about 50% of your time testing and debugging your code, which is significantly more time than you will spend coding it, you might as well make code maintenance as easy on yourself and others as possible.

Complexity is the bane of every software project. While some complexity is unavoidable, in many cases complexity can be avoided. Being able to recognize which parts of your application are complex, and understanding why, will allow you to reduce its overall complexity. As always, recognizing the problem is the first step toward fixing it.

It is also important to note that the algorithms your code relies on may be complex as well. In ...

The best content for your career. Discover unlimited learning on demand for around $1/day.