Course Taxonomy: Software Development

Effective User Acceptance Testing

Part 1: What UAT Is and Is Not

  • We will begin by describing how UAT differs from other software testing and how it fits into various software development lifecycles (including Waterfall and Agile). Along the way, we'll define a variety of key terms and identify the players.

Part 2: Understanding the Business Need

  • Business Need has many dimensions from correct computations to ease of use. We will explore each of those dimensions so you can ensure that your UAT addresses each of them in an appropriate way.

Part 3: What Could Go Wrong?

  • Of all the things we could test, which should we focus on? We will apply Risk-Based testing to focus our UAT where it will be most valuable.

Part 4: "U" is for User

  • Effective UAT includes testing from the standpoint of all of the users (both active and passive ones). We will discuss ways to identify all of the users and ensure that their viewpoints are included in our UAT.

Part 5: Incremental UAT

  • UAT is usually the final gate before deployment, but any problems found at that point in the project can be costly and time-consuming to correct. So we will introduce an incremental approach to UAT that can be integrated into any software development lifecycle (even Waterfall). This incremental approach enables you to identify issues earlier (when they are easier to fix), and reduces the likelihood of unpleasant surprises at the project's end.

Part 6: Preparing Test Data

  • Good tests require appropriate test data. We will discuss how to identify and prepare test data that will enable good Acceptance Testing. Along the way we will discuss the limitations, dangers and (in some cases) illegality of using production data for testing, and we will look at options for addressing those issues.

Part 7: The Acceptance Test Plan

  • As the old adage says, "Fail to plan; plan to fail." The plans for UAT will be different from those for other testing activities. We will provide guidance for UAT plans, including how to find the "sweet spot" of providing enough guidance to ensure effective and repeatable tests, while enabling the testers to exercise the system as they will use it after it is deployed.

Part 8: Performing UAT

  • Testing is more than just using a computer. We will provide guidance for how Acceptance Testers should operate while performing UAT. We will discuss following UAT plans as well as going beyond them to explore how the system works. We will also discuss evaluating test results, reporting issues and raising questions.

Part 9: "A" is For Acceptance

  • We will finish with a discussion of deciding if the system is acceptable or not. We will explore this both from each tester's perspective, and for UAT as a whole. Along the way, we will talk about "minor" defects, unresolved issues, and what it means for the system to be "good enough" in a particular context.

Agile Testing (ICP-TST)

Part 1: Agile Testing Mindset

Much like Agile itself, many of the Agile testing techniques where espoused well before the Agile Manifesto was created. But Agile testing is much different from testing performed during traditional software development approaches. This topic anchors the ideas of Agile testing in earlier work, while also providing insight into the major differences between Agile testing and testing performed as part of traditional (phased-based) software development.

The 12 Principles of the Agile Manifesto establish guiding principles for not only the Agile movement but Agile testing as a discipline. The Agile mindset includes: Quality is not “owned” by a particular role in Agile; Testers become facilitators of the team’s quality efforts; Agile testing provides critical insights and feedback into the software process. This topic helps learners understand how the Agile Manifesto is realized within an Agile testing process and approach, and to adopt the requisite Agile mindset.

  1. Overview of Agile Testing
    • Origins of Agile Testing
    • Agile Testing vs. Traditional Approaches
  2. Mindset & Culture
    • Agile Testing Principles
    • Whole Team Approach
    • Building Quality In
    • Continuous Improvement and Feedback
    • Ingraining The Agile Testing Mindset (Hands-on Exercise)

Part 2: Testing Techniques

Testing activities can be broken into various categories (or Quadrants) of testing based on their purpose and value. Automated testing can be performed at various levels (the automation pyramid) within a software application, and appropriate testing techniques must be applied to each. This topic provides the learner with a sound understanding of the purpose of various categories of testing, opportunities for automation, and testing techniques so they can be applied appropriately and at the right time within an Agile environment.

Developer testing of individual software units and associated components is critical to detecting implementation defects within the software. Unit and component tests are leveraged within TDD as well. This topic helps the learner to thoroughly understand the purpose and approach to successfully implementing unit and component testing on Agile projects and how testers support developer testing during development cycles.

Test-Driven Development (TDD) and its derivatives, Acceptance Test-Driven Development (ATDD), Behavior-Driven Development (BDD) and Spec by Example are techniques for assuring that Stories are implemented in a manner that satisfies the customers’ needs. This topic helps the learner to thoroughly understand the purpose and approach to successfully implementing these techniques on Agile projects.

Testing of User Stories is critical to successful development of software within an Agile project. This testing is often performed using the techniques above but can be done in other ways as is appropriate or necessary. This topic enables the learner to thoroughly understand the various options for testing User Stories during software development; this is an extension to ATDD to include boundary conditions and other types of testing such as exploratory testing.

  1. Categories of Testing
    • Agile Testing Quadrants of Categories
    • Automation Pyramid – Introduction
    • Testing Techniques
  2. Collaborating with Developers
    • Unit and Component Testing
    • Pairing Between Developer and Tester
  3. Example Driven Development
    • Acceptance Test-Driven Development (ATDD)
    • Behavior-Driven Development (BDD)
    • Spec by Example
  4. Feature and Story Testing
    • User Story Testing
    • Feature Testing
    • Exploratory Testing
    • Non-Functional Testing

Part 3: Agile Testing Process

Testing during an Agile project is team-oriented, so it is common for every member of the team to provide some level of testing support. This includes the Product Owner and other Business Representatives and the programmers in addition to the testers. This topic provides the learner with an understanding that within an Agile project, the entire project team is responsible for testing activities, with a specific focus on how this affects specific roles.

Lightweight planning and documentation are typical of Agile projects. The best Agile projects do just enough planning and documenting to support project activities and the needs of the end users. This topic provides the learner with an understanding of how lightweight test strategy and planning is performed on Agile projects, and how decisions are made regarding what type of test documentation, records, metrics, and reports are needed and how much is enough.

Agile projects employ a variety of techniques around the delivery of the product, including Time-boxed Iterations and Continuous Delivery, that all have a very strong focus on testing. This topic helps the learner to appreciate all of the various ways that testing is used in the “End-Game” activities (which don’t just happen at the end of the Agile project!)

Multiple environments are often necessary to support testing activities during iterations and the release process. This topic provides the learner with an understanding of the typical test environments that must be set up and maintained to support testing activities during iterations and releases and how the product must be managed as it progresses through those environments.

Distributed teams are a fact of life in most organizations and must be dealt with to make Agile testing initiatives successful. This topic provides the learner with an understanding of how communication and coordination of testing activities can be most effective on distributed teams.

  1. Roles and Responsibilities
    • Team-Based Testing Approach
    • Typical Business Representative Role in Testing
    • Typical Programmer Role in Testing
    • Typical Tester Role in Testing
    • Role of Test Managers in Agile
  2. Test Strategy and Planning
    • Different Strategies Based on Levels of Precision
    • During Iteration Planning/Kickoff
    • Lightweight Test Plan Documentation
    • Defect Tracking and Management
    • Results Reporting
    • Test Metrics
    • Regression Tests
  3. Successful Delivery
    • Time-Boxed Delivery
    • Continuous Delivery
    • Post-Development Test Cycles
    • Iteration Wrap-Up
    • Definition of a Release/End Game
    • User Acceptance Test (UAT)
    • System-Wide and Cross-Team Testing
    • Post-Release Testing
    • Documentation for Regulatory Requirements
  4. Test Environments and Infrastructure
    • Typical Environments for Test
    • Build Pipeline
    • Automated Builds
    • Testing the Proper Build
    • Test Data Management
  5. Working on Distributed Teams
    • Distributed Team Communication
    • Distributed Team Coordination

Test-Driven Development with Java

Part 1: Agile Overview

Test Driven Development is a key component of the Agile Software Development Methodology and of the overall DevOps movement. So it is helpful to have at a minimum a high-level understanding of Agile practices and scrum ceremonies and TDD fits into the overall Agile, Scrum and DevOps landscape. Part 1 serves as a leveling exercise to ensure that team member is speaking the same language during upcoming labs and discussions.

  1. What is Agile Software Development
    • DevOps Overview
    • The Agile Manifesto
    • Scrum vs Agile
  2. Components of Agile
    • User Stories
    • Tasks
    • Bugs
    • Automated Builds
    • Automated Tests
    • Continuous Inspection
  3. The Role of TDD in Agile Development
    • Automated Unit Tests
    • Automated Acceptance Tests

Lab: Explore the Board of an Agile Project

  • Kanban Board
  • User Stories
  • Tasks
  • Bugs
  • Work in Progress
  • Burndown Chart

Part 2: Unit Testing

Unit Testing is a critical component of Test Driven Development (TDD). Small units of code are tested throughout the development process, which isolates functionality to ensure that individual parts work correctly.

  1. Unit Test Fundamentals
    • Reason to do Unit Testing
    • What to Test: Right BICEP
    • CORRECT Boundary Conditions
    • Properties of Good Tests
  2. Frameworks
    • What is JUnit
    • JUnit Building Blocks
    • Test Cases
    • Test Suites
    • Examples
  3. Agile Testing Strategy
    • Agile Testing Quadrant
    • Automation Pyramid
    • Assertions
  4. Test Attributes
    • Setup / TearDown
    • JUnit Lifecycle
    • System Under Test
    • Test Design Strategy
    • Naming our Tests
    • Exceptions

Lab: Introduction to Unit Testing

  • IDE and Project Setup
  • Running our first Unit Test
  • Explore Junit framework
  • Test Attributes
  • Assert Statements

Part 3: Test Driven Development

Essential TDD techniques require developers write programs in short development cycles, and there are critical steps that must be taken. Tests are created before the code is written. Once the code passes testing, it is refactored to adhere to the most effective and acceptable standards.

  1. TDD Rhythm
    • TDD Overview
    • Red, Green, Refactor
    • TDD Benefits
  2. Sustainable TDD
    • Development without TD
    • Test Last
    • Test Last in Parallel
    • Test Driven Development
  3. Supporting Practices
    • Collective Ownership
    • Continuous Integration
  4. Eight Wastes of Software Development
    • Ripple effect of defects
    • Partially Done Work
    • Extra Features
    • Relearning
    • Handoffs
    • Task Switching
    • Delays
    • Defects
  5. Test Automation
    • Automate, Automate, Automate
    • Automate Early and Often
    • Additional Topics Identified

Lab: Test Driven Development

  • Start Test Driven Development on our example App
  • Write unit test cases
  • Experience RED, Green, Refactor Process

Part 4: Principles of Agile Development

TDD is directly influenced by design, so it will be a priority to take this into context during implementation. Considering design principles will enable teams to experiment with different approaches, and gear towards more functional programming.

  1. Design Principles Overview
  2. Coding Principles
  3. isolation of the SUT
  4. Developing independently testable units
  5. Test doubles
    • Introducing test doubles
    • Stubs
    • Fakes
    • Mocks

Lab: Continue development on example App

  • Setting up Test doubles for our example app
  • Discuss and implement test dummy and test stubs

Part 5: Refactoring

Refactoring is another essential technique of TDD, and most software development teams are most likely doing some form of refactoring regularly. Refactoring can be used in a number of different workflows which will be explored in this Part.

  1. Why Refactor?
    • Red, Green, Refactor
    • Benefits
    • Development without TDD
  2. Refactoring Methods
  3. Refactoring Cycle
    • Reduce Local Variable Scope
    • Replace Temp with Query
    • Remove Dead Code
    • Extract Method
    • Remove Unnecessary Code

Lab: Continue our example project

  • Implement new test cases
  • TDD Cycle
  • Discuss and implement Refactoring Needs

Part 6: Pair Programming

Pair Programming is an effective way to improve code quality. In this Part, we will discuss pairing and how it leads to better software design, and a lower cost of development.

  1. Pair Programming
    • Pairing Setup
    • Results: Time
    • Results: Defects
    • How it works
  2. Advantages of Pairing
    • Both Halves of the Brain
    • Focus
    • Reduce Interruptions
    • Reduce Resource Constraints
    • Multiple Monitors
    • Challenges
  3. Pairing Techniques
    • Pair Rotation
    • Ping Pong Pairing
    • Promiscuous Pairs
    • Pair Stairs
    • Cross-Functional Pairing

Lab- Experience pair programming and continue developing our example app

Part 7: Acceptance Test Driven Development (ATDD) & Behavior-Driven Development (BDD)

Acceptance Tests are an important form of functional specification, and Behavior Driven Development dictates what happens as an effect of these tests being run. In this Part, we will cover the difference between them, and how they are closely related.

  1. Acceptance Testing
    • Acceptance Tests
    • Why Acceptance Tests?
    • Acceptance Test Execution
    • Who Writes Acceptance Tests
    • Pair Test Writing
  2. Best Practices for Effective Testing
    • Keys to Good Acceptance Tests
    • Writing Acceptance Criteria
    • Acceptance Test Example
    • Acceptance Test-Driven Development (ATDD)
  3. BDD vs. ATDD
    • Specification by Example
    • BDD Frameworks
    • BDD Examples

Lab: Experience ATDD and BDD

  • Experience ATDD or BDD and discuss the impact to TDD

Part 8: Advanced TDD

In order to implement Unit Tests efficiently, it is critical that developers understand their properties.

Lab: Demonstration for Mocking/doubles with our example App

  1. TDD Solutions
    • Continuous Unit Testing
    • Collective Ownership
  2. Advanced Unit Testing
    • Unit Testing Legacy Applications
    • Techniques for Legacy Code
    • External Dependencies
    • Mocking frameworks
    • Unit Testing the Database
  3. Outside In vs Inside Out
    • Working with database
    • Working with mocking frameworks
  4. Test Strategy
    • Continues Integration
    • Batch Execution of TestCases
  5. Unit Test Examples
    • More Tests
    • Algorithm
  6. Advanced Refactoring

Lab: Demonstration for Mocking/doubles with our example App

  • Working with database
  • Working with mocking frameworks

Part 9: Simulation

Experience Agile development with test driven development and pair programming

Test Automation Boot Camp (ICP-ATA)

Part 1: Introducing Test Automation

  1. Watch an Automated Test
  2. Requirements
    1. Exercise: Identify different requirement types
    2. Exercise: Make requirements testable
  3. Testing Types
    1. Black-box vs. white-box
    2. System testing vs. integration testing vs. unit testing vs. acceptance testing
  4. Application Types
    1. Process-driven or data-driven: no "one size fits all"
    2. Exercise: Define different kinds of tests for different application types
  5. The Alphabet Soup of Tools and Methods
    1. Selenium. Gherkin. Cucumber. HPQC. Jira—you hear all of these. What do they mean? How do they fit together? Which do you need and which can you safely ignore?
    2. Exercise: Testing facts and fallacies

Part 2: Preparing for Test Automation

  1. Effective Partitioning Schemes
    1. Exercise: Structure a system into processes (actor goals), activities, actions
  2. Use Cases and Test Cases
    1. Exercise: Create a test case for a single activity from a written use case (happy path)
  3. Behavior-Driven Languages
    1. Exercise: Write a test case as a Gherkin scenario
  4. Modeling and Diagramming Techniques
    1. Exercise: Construct a UI navigation map for normal and alternate flows
  5. Equivalence Partitioning and Boundary Value Analysis
    1. Exercise: Define input value choices and use TAME to construct test alternatives

Part 3: Recording Automated Tests

  1. Automated Test Steps:
    1. Pre-checks, Inputs, Events, and Post-Checks
    2. Exercise: Write the steps of an automated test
  2. Record and playback a single test
    1. Exercise: Record and play back a test in Selenium WebDriver

Part 4: Dissecting Automated Tests

  1. Recorded Test Steps
    1. Exercise: Examine recorded steps in Selenium
  2. UI Element Repositories
    1. Exercise: Examine the components of a UI page
    2. Exercise: Create path expressions to locate page elements

Part 5: Assembling Automated Tests from Modules

  1. Test Suites, Test Cases, and Modules
    1. Exercise: Partition a recorded test into reusable modules
  2. Modular Test Development
    1. Exercise: Construct test cases from existing modules
    2. Exercise: Construct new modules for alternate behaviors

Part 6: Coding Automated Tests

  1. Code always, Code sometimes, or Code never
  2. The Skills Pyramid
  3. Open-source and commercial tools
    1. Exercise: Compare tools and team capabilities

Part 7: Exploiting Automated Testing

  1. Test-driven development: test cases as specifications
  2. Data-driven tests
    1. Exercise: Define data tables for equivalence partitions and boundary value analysis
  3. Multi-platform and cross-browser testing
    1. Exercise: Run test cases on multiple web browsers

Part 8: Enabling Continuous Integration with Test Automation

  1. Regression test suites
  2. Development events trigger test runs
  3. Configure test subsets
    1. Exercise: Define a minimal "smoke test" and contrast with a full regression suite
  4. Report test results
    1. Exercise: Design a dashboard for quick reporting of test results

Part 9: Course Summary

  1. Quiz: Testing facts and fallacies
  2. Exercise: Plan your own test automation strategy