Author: ziuziu on 25-11-2016, 02:29
http://i84.fastpic.ru/big/2016/1124/b9/6c9fce81201cb4ee76f2764f630d90b9.jpg
Improving Testability Through Design
WEBRip | English | MP4 + Project files | 1024 x 768 | AVC ~294 kbps | 15 fps
AAC | 126 Kbps | 44.1 KHz | 2 channels | 4h 36mn | 852.9 MB
Genre: eLearning Video / Development, Programming

This course tackles the issues of designing a complex application so that it can be covered with high quality tests.
A well designed application is not necessarily the one which has a perfect separation of layers, or the one which perfectly implements some predefined design patterns. It is certainly a plus to have these two goals met, but that is not sufficient to make the application really good. We can learn the most about one application by reading the source code of particular methods embedded deep inside of it. A common for loop often reveals more about the design than the whole diagram depicting responsibilities of an application layer in which it is located. The devil is in the details. The best of all intentions in design fails miserably when the low-profile design of small, seemingly unimportant classes is misconceived. In this course, the order of decisions is sorted bottom-up. It is the small class to which we pay attention the most. Only when all things are in place at the microscopic level can we discuss responsibilities of layers, isolation of modules and other high profile topics. The result is a well-built, easily testable and easily maintainable application.
Content:
01. Assessing Reliability of Tests 00:18:35
01. Introduction 01:37
02. Tests Coverage Considerations 02:30
03. The Value of Tests 02:01
04. The Quality of Tests 01:58
05. Introducing the Demo Application 02:45
06. Adding Properties to a Class 02:33
07. Identifying Some of the Design Issues02:14
08. Summary 02:53
02. Developing an Application the Old Way 00:38:20
01. Preparing Tests for Properties 01:54
02. Testing Boundary Conditions 02:52
03. Improving the Boundary Conditions Tests 02:31
04. Defining the Circle 02:41
05. Adding an Operation to the Frame 02:02
06. Completing Tests for the Operation 03:02
07. Completing the Feature 01:50
08. Adding More Tests 02:23
09. Notes About how to Improve Unit Tests02:13
10. Adding Another Feature and Its Tests 03:33
11. Adding a Concrete Implementation of the Circle 01:35
12. Trying the Demo Application 01:24
13. Exposing the Defects 02:03
14. A Case When It's Better Not to Mock 02:23
15. Exposing a Serious Defect 03:03
16. Summary 02:45
03. Guidelines of Redesign for Reliability 00:46:37
01. How Defects Are Introduced 03:34
02. How to Avoid Introducing Defects 02:40
03. How to Improve Tests 02:33
04. Factoring Out Common Logic From Tests02:37
05. Using Common Testing Methods 01:19
06. Decoupling Library Test Code From Concrete Types 02:50
07. Completing the Testing Library for Decimal Properties 02:41
08. Avoiding Null Reference Exceptions 02:48
09. Introducing the Non-Default Constructor 02:46
10. Making Plans for Constructor Tests 02:10
11. Single vs. Multiple Tests per Test Method 03:00
12. Designing the Library for Constructor Tests 02:48
13. Beginning the Library Implementation 01:37
14. Adding Features to the Library 02:51
15. Completing the Constructor Testing Library 01:48
16. Making the Constructor Test Pass 01:39
17. Discussion on Declarative Tests 02:04
18. Discussion on Remaining Transition Tests 02:15
19. Summary 02:28
04. Getting the Most Out of Immutable Objects 00:43:13
01. About Values 01:43
02. Immutable Objects as Values 01:32
03. Example of Immutable Objects in C# 03:10
04. More Measurements on C# Performance 02:12
05. Performance of Immutable Collections 02:46
06. When to Be Careful With Immutable Collections 01:44
07. One Common Mistake With Immutable Collections 01:38
08. Different Ways to Validate Data 02:40
09. Problems When Validating in More Than One Way 03:08
10. Benefits From Validating Only in the Constructor 02:06
11. Transactional Qualities of Operations on Immutable Objects 02:29
12. Avoiding Processing Overhead in Immutable Operations 01:27
13. Immutability and Equality 01:05
14. Equality in Objects With Identity 02:39
15. Example of Immutable Structure 01:27
16. Immutable Structure Implementation 01:58
17. Designing the Immutable Circle Interface 02:36
18. Implementing the Immutable Circle Class 02:44
19. Implementing the Immutable Frame Class 02:28
20. Summary 01:32
05. Improving the Unit Tests 00:42:43
01. About Different Kinds of Tests 01:57
02. About Integration Tests 03:38
03. Overview of Types That Will Be Tested02:38
04. Preparing the Immutable Structure Tests 01:51
05. Designing the Immutable Structure Tests API 01:53
06. Beginning the Library Implementation 01:33
07. Implementing the Assert Method 01:58
08. Completing the Library 01:15
09. Testing the Rectangle 02:07
10. Completing the Immutable Structures Tests 02:04
11. Testing the Circle Constructor 02:24
12. Testing the Geometry 02:14
13. Testing the Immutable Methods 02:05
14. Preparing the Equality Testing Library 01:43
15. Design of Declarative Testing Methods02:11
16. Assert Method 01:44
17. Test Cases for Testing the Equals Methods 01:22
18. Test Cases for Operator Overloads 01:55
19. Demonstrating the Equality Testing Library 01:38
20. Discussion 02:51
21. Summary 01:29
06. Crossing Responsibility Boundaries 00:41:42
01. Defining Responsibilities of a Class 01:49
02. Defining Responsibility Boundaries 02:07
03. Different Kinds of Test Doubles 02:24
04. Identifying Responsibilities of the Circle Class 01:28
05. Moving Somebody Else's Responsibilities Out 02:36
06. Identifying the Problems 02:30
07. Motivation Behind the Visitor Pattern01:40
08. The Visitor Pattern 01:39
09. Identifying Weaknesses in the Visitor Pattern 01:31
10. Modified Visitor Pattern Implementation 01:57
11. Applying the Visitor Pattern 02:31
12. Testing the Interaction With Visitors01:53
13. Completing the Interaction Tests 01:51
14. Identifying Responsibilities of the Frame Class 02:07
15. Pros and Cons of Mocking in Unit Tests 02:30
16. Integration Tests in Place of Unit Tests With Mocks 01:33
17. Using Manually Coded Mocks 02:11
18. Using Concrete Visitor as a Spy 01:34
19. Using the Fluent Interface to Simplify Integration Tests 01:15
20. Mocking Framework vs. Manual Mocks 01:35
21. Running the Tests 01:07
22. Summary 01:43
07. Managing Operations on Database and External Systems 00:45:09
01. The Problem of Connecting to External Systems 04:23
02. Designing the Actual User Interface 04:41
03. Layering the Application 04:17
04. Referencing Issues Between Layers 03:15
05. Demonstrating the Data Mapping Layer 03:25
06. Final Organization of Layers 01:31
07. Adding a Data Access Layer to the Application 02:48
08. Adding the Data Gateway to the Application 03:03
09. About Testing the Layered Application02:18
10. Handling Database Errors - the Incorrect Way 02:30
11. Handling Database Errors - the Correct Way 04:02
12. Summary 04:05
13. Course Summary 04:44



http://i84.fastpic.ru/big/2016/1124/93/3540493b68dcd91e3366d4b9b6015393.jpg
http://i84.fastpic.ru/big/2016/1124/54/021612ca40e36106a8dd017a5fa5d454.jpg
http://i84.fastpic.ru/big/2016/1124/24/7c321332337d33ebd5fb8277e22e7c24.jpg

Download link:
Links are Interchangeable - Single Extraction - Premium is support resumable

Dear visitor, you are browsing our website as Guest.
We strongly recommend you to register and login to view hidden contents.

Information
Would you like to leave your comment? Please Login to your account to leave comments. Don't have an account? You can create a free account now.
MEMBER PANEL

Register | Forgot Password
OUR NETWORK
ONLINE SUPPORT
ADVERTISING
Link 1
Designed by gfxbing.com
Go Daddy Web Hosting! A completely unique experience - only  $1.99 / mo from Go Daddy! - 468x60