You can learn anything on Udemy. Start today with one of our 10,000+ online courses

The Art of Unit Testing & TDD Master Class in .NET

With Roy Osherove. Recorded live in class during a five day course.
15 reviews
WHAT'S INSIDE
  • Lifetime access to 17 lectures
  • 9+ hours of high quality content
  • A community of 400+ students learning together!
TAUGHT BY
SHARE

The Art of Unit Testing & TDD Master Class in .NET

With Roy Osherove. Recorded live in class during a five day course.
15 reviews

IMPORTANT:

This course is no longer available for new students on Udemy. You can grab it at http://tddcourse.osherove.com

---------------------------------------------------------------------------------

---------------------------------------------------------------------------------

Recorded LIVE during five days of TDD master class with Roy Osherove.

All videos are downloadable to be viewed offline.

Hello everyone. My name is Roy Osherove. You might have read my book ““The Art of Unit Testing ”.

When we approach the skill of test driven development, I can see three distinct sub skills needed to accomplish it:

Writing good unit tests

Writing them test first

Design skills.

My book deals with the first skill: Writing good tests.

In this Unit Testing Best Practices program, recorded live during several TDD master classes, I deal with both Good unit tests, and test first development.

I focus very little on design skills, because I believe that focusing on all three skills at the same time can be very challenging to learn.

On day 1, we begin at absolute zero: no knowledge of writing unit tests is needed, and we go through writing our first tests together, discussing readability and maintainability as we go along.

Then we move into test driven development, and the string calculator kata as a demo that the students need to complete.

On day 2, we talk about mock objects, stubs and fakes. We talk through a couple of different scenarios where fakes are needed, and how to write hand written fakes. This is an important skill that can help us a lot, even when we know how to use isolation frameworks. We then move from hand written fakes to Isolation (mocking) frameworks. We discuss when they bring to the table, and contrast a few of the isolation frameworks, their APIs and their design in this Unit Testing Tutorial course.

We also discuss the idea of constrained and unconstrained isolation frameworks, and why some frameworks have more abilities than others.

On day 3, we focus on writing good tests. We start by reviewing test code written by others, and learn the essential skill of sharing knowledge with others about how to write unit tests, and how to do test reviews. We also revisit methods of writing readable, maintainable and trustworthy tests.

On day 4, we focus mainly on legacy code, ad refactoring techniques on breaking it. We take a look at extract and override, refactoring static classes into instance classes, and more. We also finish up with using an unconstrained isolation framework (Typemock isolator) to test legacy code.

On day 5, I usually do exercises on real production code written by my students at my own company. In this video series, I have chosen to incorporate a few advanced ideas as part of the learning process: We look at refactoring complex validation methods to extract and override for testability, and how to create domain specific testing isolation frameworks.

To be able to learn Unit Testing Best Practices take this course now.

    • One year programming
    • Knowledge about interfaces, inheritance and virtual methods.
    • No Unit Testing Experience Needed
    • Over 17 lectures and 9 hours of content!
    • Learn the basics of Unit Testing
    • Learn the basics of TDD
    • Discover Mocks, Stubs and the differences between them
    • Learn to test legacy code
    • Learn to review other people`s tests so you can teach them good practices
    • Unit Testing Advanced Techniques
    • Developers in Java, C++ and .NET

CURRICULUM

  • SECTION 1:
    The Basics
  • 1
    Special Offer
    Text
  • 2
    Unit Testing And TDD 101
    01:55:52

    Roy Explains TDD and unit testing from scratrch, including how to setup the environment for flowing development.

  • 3
    Test Driving a String Calculator
    27:29

    Roy Test Drives the creation of a string calculator with explanations on best practices.

  • SECTION 2:
    Fakes, Mocks and Stubs
  • 4
    Test Driving a Console Application Using String Calculator
    16:53

    In this talk, Roy adds a new layer to the application, and uses the existing string calculator, integrated and used from inside a console application.

    It is also the first time the idea of a mock object is introduced.

  • 5
    Introduction to Hand Written Fakes, Mocks and Stubs
    07:18

    Roy Introduces the idea of mocks, fakes and stubs and shows how to hand write them, and when it makes sense to hand write them.

  • 6
    Mock Objects Labs (without solutions)
    45.25 KB

    Mock Objects Labs (without solutions)

  • 7
    Isolation Frameworks
    01:01:26

    Roy reviews the basic differences between the various isolation (ocking) frameworks. Also explained is the difference between profiler based and proxy based frameworks.

  • 8
    Demos for mock objects session
    5.69 MB

    Demos for mock objects session with LoginManager

  • SECTION 3:
    Test Review Insights
  • 9
    Test Review Practices
    01:00:30

    Roy explains what to look for when reviewing other people's tests

  • 10
    NedrDinner Test Review
    27:17

    Roy Reviews NerdDinner project with the class

  • 11
    Unity Test Review
    25:37

    Roy and the class Review Unity.codeplex.com tests

  • SECTION 4:
    Legacy Code
  • 12
    Using Extract & Override
    21:33

    In this session Roy covers the Extract & Override refactoring technique, and when it might be useful in legacy code situations.

  • 13
    Static Forwarding on a real legacy app
    13:44

    another refactoring technique

  • 14
    Testing Legacy Code with Typemock Isolator Deep Dive
    20:07

    Roy Tests BlogEngine.NET with Isolator

  • SECTION 5:
    Bonus tracks on advanced patterns
  • 15
    Code Excavations and Domain Specific Test Frameworks
    54:14

    Roy Shows how to build a domain specific test framework using the idea os "Code Excavations"

  • 16
    Testing Complex Validation Knowledge using Extract & Override
    43:34

    Roy shows how to test and complex validation method with refactoring.

  • 17
    Mocking On The Edge
    49:53

    How far can you take a tool like typemock Isolator? What wouldyou do with it?

    Roy shows very advaced uses of Isolator and any profiler based framework.

RATING

  • 9
  • 5
  • 1
  • 0
  • 0
AVERAGE RATING
NUMBER OF RATINGS
15

REVIEWS

  • Peter Davidsen
    Very nice for beginners to unit testing

    This course is a great way for people who are starting to write unit tests, and wants to do TDD. However if you already has experience writing tests, using mocks and so on, you will not get as much out of this. I write unit tests dailiy but have never really gotten into TDD, and this course made me understand it very easily. The quality of the videos themselves are at times a bit blurry which is annoying as there are a lot of code demos. Roy also presents the use of different mocking frameworks and cases where testing isn't as straight forward as you'd might hope (external apis), fx. testing Silverlight applications.

  • Søren Engel
    Great course material, but lacks well-documented exercises

    The course material itself is really great, no questions about that. I started with little, to none, experience on how to write unit tests and drive the development process using TDD. By the time being, I feel that I am a lot more confident within the two aspects. However, I am really missing more well-crafted exercises, as videos often ends with a "we'll continue doing X and Y in the exercises", whereas a lot of what it meant to be done here is underspecified for the viewer of the videos. It would be of great help, if the course had more exercises included, explaining what the assignments were, as well as answers to these exercises. So far this is only done in section 2 (Mocks), and even this document is not all too well-organized. My conclusion is that this course offers a lot of expert knowledge on the subject, but it leaves the viewer with too little practical hands-on experience, due to the absence of well-documented exercises.

  • Ian Ceicys
    Great Course to learn unit testing

    This is a great course to learn unit testing!

  • Jorge Crisostomo
    Amazing course!

  • 30 day money back guarantee!
  • Lifetime Access. No Limits!
  • Mobile Accessibility
  • Certificate of Completion
STUDENTS WHO VIEWED THIS COURSE ALSO VIEWED:
MORE FROM Roy Osherove