Chapter 8, Driving Development with Customer Tests, introduces the ability to associate a review with an existing recording. For this feature, we need to provide some additional Web services, and we need to be able to modify the existing database. We also see how easy it is to extend the existing functionality to be able to support the new feature.
Chapter 9, Driving Development with Customer Tests: Exposing a Failure Condition, describes an unsolved issue that was not fully addressed in Chapter 8. The issue arises when a user tries to add a review to a recording that the reviewer has already reviewed. This should not be allowed by the system. In this chapter, we first specify the problem by writing new customer and programmer tests. After the tests fail, we implement a solution. This solution is relevant to the database access layer as well as the services.
Chapter 10, Programmer Tests: Using Transactions, continues the theme of the previous chapters by solving a problem that was caused by improper updates to the database, including issues with the programmer tests as well as the customer tests. The main issue is related to the program adding a Reviewer entity when a Review is created. If for some reason the Review is not added properly, we should automatically delete the Reviewer entity, so there should never be a Reviewer entity without a Review. The code that we implemented in Chapters 8 and 9 did just this. The solution that is implemented in this chapter uses the transaction support in SQL Server to remedy this problem. It also demonstrates the extensibility of the solution by allowing the relatively easy insertion of transaction support after the code has been written.
Chapter 11, Service Layer Refactoring, addresses the need to move common functions that were developed in Chapters 8 through10 into a new layer, called a Service Layer. We build this new layer as part of the last feature, which is to implement a Web client (which we focus on in Chapter 12, Implementing a Web Client ). This chapter demonstrates the evolving nature of the architecture based on new functionality. We also address dependency management, which is important when building layered software architectures.
Chapter 12 describes how to write programmer tests when implementing an ASP.NET Web client. The chapter addresses the issues associated with writing tests for user interfaces.