Course 344:
Agile Testing Methods for Developers and Testers

(4 days)

 

Course Description

Agile software development means producing usable and tested code faster than with traditional methods. In addition to practices aimed at speeding up code production, such as pair programming, agile methods also define practices for improving the quality of the delivered code through testing, such as continuous integration and test-first and test-driven development. This course explores the various Agile practices for improving the quality of software development through testing and how those practices can be applied to any form of software development, whether or not Agile approaches are adopted. In this course, we will explore Test-Driven Development, continuous integration, pair programming, and other methods and techniques introduced by the Agile software development approaches.

Learning Objectives

  • Review generally accepted testing processes to determine the benefits and drawbacks of each
  • Examine the Agile software development approaches and how testing is done in an agile manner
  •  Practice refactoring and pair programming to improve code development
  •  Employ the principles of Test-Driven Development to improve code quality
  •  Examine integration testing tools and the process of continuous integration
  • Apply Agile testing techniques to all development life cycles and all testing practices

Who Should Attend

Programmers, testers, software developers, QC managers, software project managers, and anyone else interested in the details of agile testing practices, tools, and techniques.

Prerequisites

An understanding of software development testing processes.

Course Outline

Unit 1: Testing in the SDLC

General Approach to Software Development
  • The Software Development Process
    • Exercise: Why Don’t We Get Quality Software?
    • Mandatory Elements
    • Transitions
The Classic SDLC Timeline
  •  Elements and Phases
  •  Test Stages
    • Unit
    • Integration
    • System
    • Acceptance
    • Exercise: Can We Do without These Stages?
    • Exercise: Applying All Four Stages
  • Issues with Linear Life Cycles
    • Testing in Isolation
    • Determining a True Baseline
    • The Problem with Late Testing
  • General Approaches To Quality Assurance
    • It Compiles, Therefore, It Must Work
    • Problems with Code Expansion
Unit Summary
  • Summary
  • Keys to Success

Unit 2: Test Methods

General Approaches to Testing
  • Exercise: Testing Methods
  • Prepare, Execute, Document
  • Test Cases
  • Elements of a Test
  • Sources of Test Cases
  • Exercise: Defining a Test Case
Classic Testing Methods
  • Script-Driven Testing
  • Destructive Testing
  • Cause-Effect Testing
  • Requirements Based Testing
  • Root Cause Testing
Alternate Test Execution Approaches
  • Exploratory Testing
  • Scenario Testing
Testing in Agile Development
  • Rapid Application Development
  • Test First Approach
  • Test-Driven Development
  • Extreme Programming (XP)
  • Exercise: What Components of Testing Should Be Taken from Each Method?
Unit Summary
  • Exercise: Which Method?
  • Summary
  • Keys to Success
  • Applying Test Methods to Your Testing Process

Unit 3: The Concept of Continual Testing

The Rise of Agile Methods
  • Different Reasons for Agile Software Development
  • Time – Schedule Orientation
  • The Agile Manifesto
  • Quality and Agile?
Testing from the Beginning
  • The Circle of Life
  • Agile Approach to Requirements
    • The User Story
    • Epics and themes
    • Testing against stories, epics and themes
  • Exercise: Creating User Stories, epics, and themes
  • Can There Be Too Much Testing?
  • Balanced Approach: Coding and Testing
Testing During Development
  • The Testing Frameworks
    • Test Fixtures
    • Unit Testing
    • Integration Testing
    • Acceptance Testing
  • Defining Tests
    • Defining the Unit Test
    • Defining the Acceptance Test
    • Exercise: Defining a Test from User Story
  • Setting Up and Organizing Test Cases
    • The Structure of Test Organization
    • Separate the Test Class from Code Class
    • Add Test Class to Build Class
    • Stubs, Drivers, and Mock Objects
    • Workshop: Defining Stubs and Drivers
Unit Summary
  • Summary
  • Applying Continual Testing and Test Organization to Your Testing Process
  • Keys to Success

Unit 4: Test-Driven Development Overview

Test-First Development
  • Test-First Philosophy
    • PDSA Cycle
    • Design Direction
    • Verification Method
  • A Testing Methodology?
  • How It Works
  • Workshop: Applying Test-First Approach to Requirements
Design, Code, or Test?
  • A Testing Methodology?
  • Rationale for Test-Driven Development
    • Timeboxing
    • Accommodating Change
    • “Red, Green, Refactor”
  • TDD as a Design Approach
    • Specification, Not Validation
    • Alternative to Modeling?
  • Complementary Approaches
Assessment of TDD
  • Benefits of TDD Approaches
  • Limitations of TDD
  • TDD and Automation
  • TDD Pragmatics: Project Size, Team Size, Languages
  • TDD and Traditional Testing Practices
Unit Summary
  • Summary
  • Keys to Success

Unit 5: Refactoring

What Is Refactoring?
  • Do the Simplest Thing that Can Work
  • Principles of Refactoring
  • Exercise: Refactoring
  • Bad Smells in Code
    • Cargo Cult Programming
    • Voodoo Chicken Programming
Simplification
  • Simplifying Conditionals
  • Simplifying Methods
  • Generalization
Unit Summary
  • Summary
  • Applying Refactoring to Your Development Process
  • Keys to Success
  • Workshop: Refactoring

Unit 6: Execution: Applying TDD at the Unit Level

Developer Testing
  • Developer, Programmer, Unit Testing
  • Where TDD Fits
  • Smallest Increment of Functionality
  • Rules of TDD
    • Write the Test – Red
    • Write the Code – Green
    • Refactor – Refactor
Using the Unit Testing Frameworks
  • Framework Class Hierarchy
  • Runner Class Diagram
  • JUNIT Framework (3)
  • Installing XUNIT (3)
  • Red, Green Refactor in Junit
  • Nunit Errors
  • XUnit Rest Results
  • Typical XUnit Assertion Statements (2)
  • Other Xunit Frameworks
    • CppUnit (2)
    • VBUnit (2)
    • PyUNit (2)
    • HTMLUnit (2)
    • Others (2)
Building Tests
  • Value of Self-Testing Code
  • Mock and Fake Objects
    • Abstract Methods
    • Mock Object Tools
    • Method Stub
  • Organizing Data
  • White Box and Black Box Testing with TDD
  • Tips for Building Test Classes
  • Exercise: Building Tests
Pair Programming
  • Basis for Pair Programming
  • Pair Programming Roles
  • The Tester in Pair Programming
  • Pair Programming and TDD
  • Exercise: Pair Programming
Unit Summary
  • Summary
  • Applying TDD to Your Development Process
  • Keys to Success
  • Workshop: Applying TDD

Unit 7: Continuous Integration

Background
  • Classic Integration
  • Unit and Integration Testing with TDD
  • Scheduled Builds
  • Automation
  • A Successful Build
Test Organization
  • Organizing Test Cases for Integration and Regression
  • Accessing Tests and Code
ANT
  • Background
  • ANT Configuration File
  • Similarities to Make
CruiseControl
  • What CruiseControl Is All About
  • The Build Loop
  • The Dashboard
  • Getting Started
  • Reporting
Other Approaches
  • Hudson
Unit Summary
  • Summary
  • Applying Continuous Integration to Your Development and Testing Process
  • Keys to Success
  • Workshop: CruiseControl

Unit 8: Agile Acceptance Testing

Agile Acceptance Testing
  • Acceptance Tests Come First
  • Testing Business Rules
    • Involving the Customer
    • Test-First Paradigm
  • The Safety Net Effect
FIT and FITnesse
  • Background
  • Preparation
  • What Is FIT?
    • Framework for an Integrated Test (FIT)
    • Fitnesse – FIT with a Wiki
  • Context-Driven Testing Revisited
  • Fixtures (2)
  • Setting Up Fixtures
    • Column Fixture
    • Row Fixture
    • Action Fixture
  • Exercise: Setting Up Fixtures
  • HTML Tables
  • Parsing Tables
  • FITnesse Description
  • Using FITnesse
  • Organization of Test Cases
  • Workshop: Setting Up a FITnesse Table
Unit Summary
  • Summary
  • Applying TDD and Automated Acceptance Testing to Your QC Process
  • Keys to Success
  • Workshop: An Automated Acceptance Test

Unit 9: Some Additional Testing Practices

Incorporating the Practices in Your Process
  • Phased Approach
  • Increasing Collaboration
  • What to Do First?
Applying TDD to Structured Approaches
  • Test First for Design
  • Testing Structured Code First
  • Workshop: Adding the Practices
Unit Summary
  • Summary
  • Keys to Success

Unit 10: The Bottom Line

Ideas to Use
  • Best Practices in Testing
  • Best Practices in Agile Testing
  • Highlights
Where to Go for More Information

Please Contact Your ROI Representative to Discuss Course Tailoring!