Introduction

This is one of our 3-courseAcceptance Testing collection of courses - It is for Product Owners, QA/Testers, Business Analysts and Technical Leads - people who have the ideas for new business opportunities and software products and work with the technologists who turn these ideas into software. 


Learn techniques to analyse problems, to find Stories and Examples, so you can write Specifications for new software that are understandable, stable and resilient to change.

What is Acceptance Testing?

Good Acceptance Tests are complex. Our aim in writing these high-level functional tests, is to make them understandable, stable and robust in the face of changes to the system or environment. What tools and techniques are effective? How can we avoid the common pitfalls which lead to tests that are difficult, fragile, slow and prone to intermittent failure. This course addresses these problems, by sharing proven approaches and demonstrating  techniques from complex projects, widely seen as world-class examples of the practices.


Acceptance Test Driven Development - is an approach to software development that focuses on the outcome/purpose of the software, and not the technologies or implementation details. This 'outside-in' approach results in better designed software, and replaces expensive manual testing with automated tests that are resilient to changes in requirements, allowing the software to be developed faster and with fewer defects. 

What’s In This Course?

The course builds incrementally from understanding Acceptance Testing and Behaviour Driven Development to writing Stories and Examples - learning how to expressing requirements as outcomes, i.e what the software does, not how it does it, using a mix of theory and worked examples.


There are video lessons, practical exercises, demos and suggestions for further reading and exploration, which you can study at a pace that works for you. The course also includes a recording of a live student workshop exploring a real-world problem, which demonstrates the sorts of conversations that you may expect to have, as you explore a problem with your domain experts.


The course starts with the question - "Why Acceptance Test?" and proceeds to explain:

  • The team roles and responsibilities of Acceptance Testing
  • Properties of Good Acceptance Tests
  • What to Test 
  • How Test First Improves Design, and
  • Techniques we use to write effective Acceptance Tests that describe WHAT we want the system to do, and not HOW it will do it.


We explore the link between an effective, story-based, approach to requirements and practise the skills to map from Story to Acceptance Test. We share real world examples of Executable Specifications and set some problems for you to practise writing tests using these techniques:

  • Defining the Behaviour of the System
  • Event Storming - Understanding Your Problem
  • Capturing & Translating Requirements
  • Story-Mapping
  • Specification by Example
  • Domain Specific Language


The course is built around a "Four-Layer Approach" to organising and developing testing infrastructure to make tests easy to write, easy to understand, and flexible in the face of system change, and explores:

  • Properties of Good Acceptance Tests
  • How 'Test First' Improves Design
  • Finding Stories & Examples

The Course concludes by looking at the scope of Acceptance Testing and Test strategy - how effective, efficient test cases in complex systems.


Exercises

There are three exercises for you to apply what you have learned: 

  • To create specifications without implementation detail
  • Story-mapping, to capture narratives, activities and stories
  • Finding stories and examples - followed by a demo showing Dave's solution


Course Objectives

  • To learn tools and techniques to analyse problems in a way that helps to determine which product features to develop.
  • To develop a team-work approach to software development, that overcomes the communications gap between 'the business' and 'the dev team'.
  • To practise effective story-writing using a combination of “Story Mapping” and “Specification by Example” techniques.
  • To learn how to create better, more outcome-focussed requirements
  • To support the creation and maintenance of “Executable Specifications” that are not compromised by changes in the system under test.

NB

These courses are not a progression from 'basic' to 'advanced'. They are tailored to suit the different roles involved in software development. You only need the one course that's the best fit for you.


If you want to learn more about test infrastructure and translating Executable Specifications into robust software, then the next course in the collection - "ATDD & BDD - From Stories to Executable Specifications" may be a better course for you.