Writing Highly Maintainable Unit Tests

سرفصل های دوره

This course will teach you how to develop maintainable and sustainable tests as your production code grows and develops.

1. Course Overview

1. Course Overview

2. Understanding Provable Code Correctness

1. Putting Tests into the Frame

2. Version Check

3. What Follows in This Course

4. Proving Correctness of Code

5. Testing Correctness at Run Time

6. Inventing Automated Tests

7. Inventing the Test Runner

8. Summary

3. The Importance of Knowing What to Test

1. The Problem of Choosing What to Test

2. Changing the Class to Support State Testing

3. Implementing a State Test

4. On Multiple Assertions in One Unit Test

5. Completing State Tests

6. Implementing an Interaction Test Through Derivation

7. Implementing an Interaction Test Through Interface

8. Understanding Regression

9. Summary

4. The Pros and Cons of White-Box Testing

1. Applying Branch Coverage Strategy

2. Assessing Usefulness of Automatic Mocks

3. Assessing Usefulness of Manual Mocks

4. Assessing Maintainability of Automatic vs. Manual Mocks

5. Leaning on the Compiler and Automatic Mocks

6. Example - Abstracting Time

7. Summary

5. Modeling Class Dependencies in Tests

1. Stubbing vs. Mocking Dependencies

2. Letting Dependencies Grow Through Refactoring

3. Evaluating Interaction Tests

4. Understanding Lifetime of a Dependency

5. Avoiding Unnecessary Unit Tests

6. Testing Temporal Coupling Between Method Calls

7. Summary

6. Gaining Resilience by Testing Against Abstract Data Types

1. Introducing Abstract Data Types

2. Writing Unit Tests Against the Abstract Data Type

3. Replacing Entire Concrete Class

4. Varying Implementation of an Abstract Data Type

5. Extending the Abstract Data Type

6. Investigating Negative Test Cases

7. Inventing Preconditions

8. Summary

7. Testing Against Interfaces to Simplify Maintenance

1. Understanding Possible Options When Deriving a Class

2. Introducing Base and Derived Test Classes

3. When Implementation Affects Abstraction

4. Separating Functional from Non-functional Requirements

5. Completing the Definition of Abstract Data Type

6. Inventing the Abstract-Test-Driven Development

7. Interface Tests in Light of the Liskov Substitution Principle

8. Summary

8. Implementing Abstract Interfaces TDD Style

1. Implementing Inheritance

2. Using Abstract Unit Tests in TDD

3. TDD-style Interface Implementation

4. Applying TDD to Discover Missing Tests

5. A Word About Naming Classes and Interfaces

6. Refactoring a Class Covered by Abstract Tests

7. Writing Tests Against Abstract List

8. Discussing the Benefits of Base Tests Class

9. Summary

9. Testing Compliance to Design Principles

1. Inventing Design Pattern Tests

2. Implementing the Design Pattern Tests

3. Testing All Aspects of a Design Pattern

4. Defining Value-typed Semantic

5. Designing the Equality Tests

6. Defining Equality Testing Rules

7. Implementing Equality Testing Library

8. Using the Equality Testing Library

9. Summary

10. Design by Contract from Testing Perspective - Binding Theory to Practice

01. Discovering Impossible Tests

02. Understanding Error Conditions

03. Division of Exceptions

04. Defining Preconditions and Postconditions

05. Avoiding Condition Checks with Contracts

06. Inheriting Contracts

07. Applying Contracts to a Production Class

08. Asserting the Preconditions

09. Implementing Contracts in Production Code

10. Removing Superfluous Unit Tests

11. Summary

12. Course Summary

179,000 تومان

افزودن به سبد خرید

خرید دانلودی فوری

در این روش نیاز به افزودن محصول به سبد خرید و تکمیل اطلاعات نیست و شما پس از وارد کردن ایمیل خود و طی کردن مراحل پرداخت لینک های دریافت محصولات را در ایمیل خود دریافت خواهید کرد.

تولید کننده: PluralSight