Acceptance Testing (Clean Coders Video Series) [Repost]

Acceptance Testing by Paul Stringer is from the cleancoders.com video series. Learn acceptance testing through these five dynamic episodes.

• The Magnificent Testing Pyramid
• Acceptance Test Driven Development - Part 1
• Acceptance Test Driven Development - Part 2
• Who, Why & When?
• Architecture, BDD & Adoption

Episode Descriptions

The Magnificent Testing Pyramid: Where do Acceptance Tests fit? In this episode, you’ll develop definitive understanding of the different layers of the pyramid, the different names, and meanings, what they’re all for, and how to apply this technical discipline effectively. The episode covers Unit, Functional, Component, Acceptance System & UI tests to unravel the mysteries of the pyramid. With this episode, you’ll see how Acceptance Tests turn out to be completely unique from all other tests in ONE very important way and have all the foundations in place to delve deeper into the specifics of Acceptance Testing in the rest of this series.

Acceptance Test Driven Development - Part 1: This episode revisits the origins of Acceptance Testing. You’ll learn about the breakthrough HP-35 pocket calculator which inspired the first example for how to implement the practice and see the very first stages of this development process. We’ll be building our own HP-35 from scratch using the latest fang-dangled app technologies and the examples and requirements from the original HP-35’s Quick Reference Guide! And what? You have in this episode Uncle Bob himself sharing how he discovered Acceptance Testing and how it provided the inspiration for him to create ‘FitNesse’ one of the first Acceptance Testing tools - You don’t want to miss this!

Acceptance Test Driven Development - Part 2: This episode picks up from where you left off in Part 1. You will continue to apply the practice of "Acceptance Test Driven Development" (ATDD) bringing to life HP-35. We put in place the first arithmetic features with development ‘driven’ by the quick reference card from an actual HP-35. In this episode. You’ll see in fine detail how acceptance tests, fixtures, unit tests and software all come together in a step-by-step walkthrough of ATDD in action. Along the way, watch how Acceptance Tests are the thing that saves Paul from creating bugs in the code. It finishes up with a completed ‘rudimentary’ YET fully functional text-based user interface and early automated test regression suite capturing all the important business details of what the software should do. This episode is key to seeing how Acceptance Testing practically helps developers get the software right earlier by bridging the detailed gap between business & developer - from the get-go.

Who, Why & When? When exactly these ‘detailed’ requirements should get written on a project? How detailed they should be? Where do they belong in the process and WHO exactly should be writing them? In this episode, we move on from the development side of Acceptance Test-Driven Development and turn to the fundamentals of how these ‘requirements’ get written in the first place. We’ll consider the impact this ‘additional’ work might have on our team’s velocity and how it actually helps planning and the accuracy of our estimates bringing greater predictability through the ‘shifting left’ of the QA process. Enjoy the chance to be a fly-on-the-wall, watching along as our intrepid team wrestle with the process of writing up-front new requirements specific enough and through example, for the development team to carry on the work of developing their HP-35 calculator.

Architecture, BDD & Adoption: When is Acceptance Testing is worth the effort & when it’s not! In this episode, Paul shares his own experiences with the adoption of Acceptance Testing and some things you can do to improve your chances of success including the importance of a SOLID software design and architecture when adopting Acceptance Tests. We’ll check in on a close cousin of Acceptance Testing: BDD, and see where the two approaches overlap, actual differences between them, what problems they solve and which is right for you. The episode finishes it up by considering the kinds of projects where Acceptance Testing is valuable and reflects on some famous examples of software that went wrong owing to missing requirements and not bugs. You’ll get a few last tips as to how to assess your own projects to see if they’re likely to benefit from adopting Acceptance Testing. If you decide that Acceptance Tests might be right for your team, Paul proposes his own 3 laws of Acceptance Testing to guide your implementation. And finally, catch up with the team as they put the finishing touches to their HP-35 Calculator and see it all come together (including those pesky UI Tests!!)