Executable Specifications: End-to-End Acceptance Testing With SpecFlow [repost]

Acceptance tests prove your solution actually works, and using them to implement executable specifications proves your solution does what it should do. In this course we look at capturing requirements as executable specifications and implementing them as end-to-end tests with SpecFlow.

This course uses SpecFlow to write automated acceptance tests at different levels, to prove your app meets the needs of different stakeholders. We'll build tests that flex the whole stack at the feature level, so the business users are happy they're getting what they want. And we'll use the same technologies to write technical acceptance tests that flex non-functional requirements, so the technical team is confident the solution is fit for purpose. The end result is a suite of tests that prove your app does what it needs to do, and does it well.

Content:

01. Introducing Executable Specifications 00:34:48
01. Introducing Exectuable Specifications 02:30
02. About the Course 01:28
03. Executable Specifications as Acceptance Tests 01:59
04. Feature Acceptance Tests 02:55
05. Technical Acceptance Tests 02:03
06. Negative Acceptance Tests 02:39
07. Stakeholders 03:00
08. Demo 1 (part 1): Features of the Demo Solution 02:42
09. Demo 1 (part 2): Demo Solution Walkthrough 02:29
10. The Demo Solution 01:09
11. SpecFlow 101 03:38
12. End-to-End Testing 01:29
13. A Real World End-to-End Testing Story 02:33
14. Why You Need End-to-End Tests 02:35
15. Module Summary 01:32
02. Acceptance Testing the Whole Stack 00:40:44
16. Introducing Exectuable Specifications 03:28
17. About the Course 01:38
18. Demo 1 (part 1): Given Steps 03:40
19. Demo 1 (part 2): When Steps 02:58
20. Demo 1 (part 3): Running the Test 02:51
21. Automating WPF 03:51
22. Demo 2 (part 1): Then Steps 03:01
23. Demo 2 (part 2): Finishing the Test 03:19
24. Automating the Browser 02:35
25. Demo 3 (part 1): Technical Steps 03:17
26. Demo 3 (part 2): Resetting State 04:50
27. Checking the Database 01:42
28. The Discontinue Feature 01:02
29. Module Summary 02:25
03. Acceptance Testing Outside the Stack 00:43:24
30. Introducing the Reorder Feature 02:04
31. Reorder by Email 03:55
32. Demo 1 (part 1): Papercut 03:09
33. Demo 1 (part 2): SMTP Stub 03:36
34. Demo 1 (part 3): Verifying Emails 03:12
35. Self-Hosted SMTP Stub 02:47
36. Reorder by Web Service 01:59
37. Demo 2 (part 1): WCF Stub 03:21
38. Demo 2 (part 2): Verifying Web Service Calls 03:03
39. Self-Hosted WCF Stub 02:36
40. Reorder by Message Queue 02:43
41. Demo 3 (part 1): Message Handler Stub 04:08
42. Demo 3 (part 2): Verifying Messages 02:19
43. Self-Hosted Message Handler 02:18
44. Module Summary 02:09
04. Technical Acceptance Tests 00:41:22
45. Introducing Technical Acceptance Tests 02:52
46. GET Product API Feature 01:10
47. Demo 1 (part 1): The GET Feature 03:03
48. Demo 1 (part 2): Automating the GET 03:09
49. Demo 1 (part 3): Negative Testing 01:47
50. PUT Product API Feature 03:30
51. Demo 2 (part 1): Discontinue With PUT 04:11
52. Demo 2 (part 2): Reorder With PUT 03:35
53. PUT Product Acceptance Tests 01:29
54. API Performance Feature 02:22
55. Demo 3 (part 1): Load Testing With loader.io 03:13
56. Demo 3 (part 2): Message Handler Stub 02:28
57. Demo 3 (part 3): Verifying Messages 01:55
58. Load and Performance Acceptance Tests 01:22
59. Performance Testing in the Cloud 03:18
60. Module Summary 01:50
05. Course Summary 00:15:57
61. Requirements as Features 04:11
62. Executable Specifications as Acceptance Criteria 04:23
63. When Not to Use Unit Tests 02:37
64. When to Use Acceptance Tests 02:08
65. Course Summary 02:36

also You can watch my other last: Programming-posts