CF

404 - Acceptance Testing: BDD From Stories to Executable Specifications

5h 33m 38s
English
Paid

404 - Acceptance Testing: BDD From Stories to Executable Specifications is a 27-lesson 5 hours 33 minutes self-paced course by Dave Farley. Unleash the power of acceptance testing as a pivotal tool for requirement specification, automation, and enhancing the quality of software systems.

Course facts

Lessons
27
Duration
5 hours 33 minutes
Level
All levels
Language
English
Updated
Instructor
Dave Farley
Price
Premium

Unleash the power of acceptance testing as a pivotal tool for requirement specification, automation, and enhancing the quality of software systems. In this course, you will discover how to express new software ideas and functionalities comprehensively for both business and developers. Transition from expensive manual testing to resilient automated acceptance tests that withstand system and environment fluctuations.

Key Learning Objectives

Learn from the expertise of Dave Farley and explore examples from renowned, large-scale projects that set the industry standard. The course illustrates the process of crafting acceptance tests as executable specifications using the BDD (Behavior-Driven Development) methodology for accurate description of system behavior.

Modern Features of Acceptance Testing

A highlighted topic in the course is "Acceptance Testing as a Programming Language for AI". You will uncover how meticulously designed acceptance tests, along with the Domain-Specific Language (DSL) approach, can vastly enhance the quality of AI-generated code, and how to utilize these specifications as precise, repeatable prompts.

Course Curriculum

  • The purpose of acceptance tests and the most effective tools and techniques to use.
  • Strategies to avoid fragile, slow, and unstable tests that tend to be flaky.
  • Methods to capture and translate requirements into formal specifications.
  • The application scope and characteristics of quality acceptance tests.
  • Hands-on exercises in writing specifications and performing story mapping.
  • Managing test isolation, asynchronicity, and instability challenges.
  • Applying acceptance testing as a precise language for AI collaboration.
  • Validating AI-generated code through effective acceptance tests.
  • Developing a testing strategy and building an effective test suite for complex systems.

Who Should Enroll?

This course is designed for engineers, testers, architects, and technical leaders who are eager to establish a dependable, scalable, and contemporary practice of acceptance testing within their organizations.

Who teaches 404 - Acceptance Testing: BDD From Stories to Executable Specifications? Dave Farley

Dave Farley thumbnail

Dave Farley is a UK-based software engineer and one of the most authoritative independent voices on Continuous Delivery, TDD, and modern software engineering practice. He is the co-author of Continuous Delivery (Addison-Wesley) — the canonical reference on the discipline — and the author of Modern Software Engineering. He runs the popular Continuous Delivery YouTube channel.

His CourseFlix listing carries three Dave Farley courses: Microservices Masterclass, TDD & BDD — Design Through Testing, and Acceptance Testing — BDD From Stories to Executable Specs. The teaching style is unusually principled — Dave's material is taught at the level of an engineer who has shaped the field's literature for two decades.

Material is paid and aimed at engineers ready to take software engineering practice as a deliberate discipline. For broader content, see CourseFlix's QA & Testing and System Design & Architecture category pages.

What lessons are included in 404 - Acceptance Testing: BDD From Stories to Executable Specifications?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 27 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Why Acceptance Test?
All Course Lessons (27)
#Lesson TitleDurationAccess
1
Why Acceptance Test? Demo
05:18
2
What is Acceptance Testing
14:37
3
Teamwork & Communications
10:54
4
BDD - Defining the Behaviour of the System
12:26
5
BDD - It's All About Behaviour
07:24
6
Event Storming - Understanding Your Problem
10:43
7
Capturing & Translating Requirements
14:03
8
Story-Mapping - Organising Requirements
10:47
9
Specification by Example
09:20
10
The Language of Exec Specs
07:45
11
Test First
05:02
12
Properties of Good Acceptance Tests
13:54
13
Acceptance Tests & BDD
10:52
14
Exercise 3 (Answers) - Finding Stories and Examples
19:09
15
Real World Worked Example - Part 1 - Finding Stories
13:25
16
Real World Example - Part 2 - Stories to Examples
14:25
17
Building a DSL for Testing
13:06
18
Managing Test Isolation
22:35
19
Protocol Drivers & Stubs
11:38
20
Testing Time
09:36
21
The Four Layer Model
14:47
22
Dealing With Intermittent Tests
16:50
23
Using the Four Layer Model in Cucumber & SpecFlow
12:08
24
Acceptance Testing as a Programming Language
17:35
25
Exercise 5 (Demo) - Programming with AI & Acceptance Tests
13:39
26
The Scope of Acceptance Tests
11:39
27
Effective Test Strategy
10:01
Unlock unlimited learning

Get instant access to all 26 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book 404 - Acceptance Testing: BDD From Stories to Executable Specifications

#TitleTypeOpen
1Exercise 1 - Specifications Without Implementation Detail PDF
2Exercise 2 - Story Mapping PDF
3Exercise 3 - Finding Stories and Examples PDF
4205 ATDD - Finding Stories and Examples - Answers PDF
5Exercise 4 - Thinking not Coding PDF
6Exercise 5 - Programming with AI & Acceptance Tests PDF
7References, Links and Recommendations PDF

What courses are similar to 404 - Acceptance Testing: BDD From Stories to Executable Specifications?

Frequently asked questions

What prerequisites should I have before enrolling in this course?
The course does not list specific prerequisites, but a basic understanding of software development and testing concepts would be beneficial. Familiarity with Behavior-Driven Development (BDD) and some experience in writing or reviewing software requirements could also help in grasping the course material more effectively.
What kind of projects or exercises will I engage in during the course?
The course includes hands-on exercises such as writing acceptance tests and exercises in programming with AI & acceptance tests. You'll engage in real-world examples, such as finding stories and examples, and exercises like building a Domain-Specific Language (DSL) for testing.
Who is the ideal audience for this course?
This course is suitable for software developers, testers, and business analysts interested in improving their skills in acceptance testing and BDD. It's particularly beneficial for those looking to automate testing processes and enhance the quality of software systems through executable specifications.
How does this course compare in depth and scope to other acceptance testing courses?
The course provides detailed coverage of acceptance testing using the BDD methodology, including modern features like acceptance testing as a programming language for AI. It covers a wide range of topics from capturing requirements to managing test isolation and using the Four Layer Model in tools like Cucumber and SpecFlow.
What specific tools or platforms are used in the course?
The course discusses the use of tools such as Cucumber and SpecFlow within the context of acceptance testing. These tools help implement the Four Layer Model to create effective and stable automated acceptance tests.
What important topics are not covered in this course?
While the course covers a broad spectrum of acceptance testing and BDD topics, it does not delve into unit testing, performance testing, or security testing. The primary focus is on acceptance testing as a means of requirement specification and quality enhancement.
How will the skills learned in this course be applicable in other areas or careers?
Skills learned from this course, such as writing executable specifications, translating requirements, and using DSLs for testing, are highly transferable to other areas of software development. They enhance communication between business and development teams and are valuable in roles focusing on software quality assurance and project management.