Modern Software Testing

Name: Modern Software Testing
Rating: 4.4 (33 reviews)

Principles, practices, patterns, and tips from the trenches

Created byMaurício Aniche

Last updated 3/2023

English

English [Auto],

What you'll learn

The most common real-world trade-offs in software testing
Different techniques to engineer more rigorous test cases
Decide between unit, integration, or system tests, as well as when or not to mock
Design highly testable units of code
Understand what makes it easy for developers to write tests

Course content

8 sections • 37 lectures • 2h 43m total length

Welcome to this course!5:12
Meet instructor Mauricio Nishi as he introduces modern developer testing, guiding you to engineer strong test cases, choose testing approaches, use mocking, and design for testability and maintainable tests.
Test to guide development vs test to find bugs4:00
Use automated tests and test code to guide development during refactoring and feature work, and to find bugs through specification-based, structural, and boundary testing, switching between modes as needed.
The laws of software testing5:59

What's engineering strong tests all about?1:23
Gut feeling testing vs systematic testing8:38
Being more systematic with domain testing13:06
Bugs love boundaries!9:42
Explore boundary testing to reveal bugs that appear when inputs cross a threshold. Test near-boundary values like 100 and 101 to exercise both sides of the condition.
Code coverage the right way!6:29
Use code coverage to improve your tests, not chase a number; it reveals untested lines and complex path combinations to strengthen your test suite.
It's not about following a recipe!2:47
TDD: is it really magical? Should I do it?8:02

Why do you want to mock in first place, and why you should want it!1:11
When to mock, when not to mock7:20
Internals vs peers: a nice way to classify mockable dependencies3:06
Stubs, fakes, and mocks: what's the difference?2:21
What's the main problem with mocks? What to pay attention to?4:45
Mocks reduce realism and introduce coupling and contract changes, making refactoring harder and requiring careful updates to mocks as production contracts change.

Why is design for testability so important?0:55
Design your system with testability in mind to make writing unit and integration tests easy, by controlling components, setting up test scenarios, and making assertions reliable.
Ports and adapters4:54
Discover how ports and adapters separate domain code from infrastructure, enabling easy testing by mocking domain ports and isolating external systems like databases and web services.
Controllability and observability3:37
Why are smaller classes better than large classes?3:56

The testing dilemmas never end!0:39
Flaky tests and how to avoid them7:02
Developers vs QA engineers2:58
How to test in a microservice world?5:22
Focus on testing a single microservice with unit, integration, and use-case tests, and mock external services to simplify validation while embracing divide and conquer and end-to-end testing costs.
Testing your legacy without having to refactor everything first3:35
Identify what makes legacy systems hard to test and build pragmatic infrastructure, including an API for data setup, to support use-case testing and observable results without large refactors.
What's mutation testing?4:26
Explore mutation testing, which creates mutants to assess how thoroughly your tests catch bugs. Learn about automation, cost, and human-in-the-loop feedback that guide real-world adoption.

Requirements

Some experience with testing frameworks in any programming language (Java's JUnit, C#'s NUnit, Python's pytest, etc)
Understanding of the basics of software design (i.e., classes, dependency injection)
Have used a mocking framework, even if only the basics of the tool

Description

Are you a software engineer that already knows how to write automated tests, but wants to get better at it? This is the course for you.

This course isn't about teaching you some testing tool or framework. It's much bigger and deeper than that. It's about explaining to you all the principles, practices, and patterns of software testing, their advantages and disadvantages, so that you can write very strong tests that are actually able to find bugs, in a very productive way.

This course addresses topics like:

How to write test cases that go beyond the happy paths?
When to go for unit testing and when to go for integration testing?
How can I use code coverage to help me improve my tests (and finally stop hating it!)?
What's the secret to write many tests?
How to make tests that run fast and are simple?
When to mock, and when not to mock something?
What's key to design testable systems?
How can I fight flaky tests?
How to test micro services?
How to test legacy systems?
What's the role of QAs if I'm the one writing tests?
... and many more!

This course isn't focused on one specific technology or programming language, and everyone can benefit from it. These principles, practices, and tips emerge from my almost 20 years of experience in helping teams write better tests.

This course will feel like a conversation between two engineers. The majority of the course is about me speaking to the camera, with a few illustrations and highlights when needed. This course is perfect for you to take while cleaning the dishes, or taking the subway, as it requires your ears more than your eyes!

Who this course is for:

Software developers that already know how to write tests, but want to get better at it!

Modern Software Testing

What you'll learn

Explore related topics

Course content

Introduction3 lectures • 15min

Engineering strong tests7 lectures • 50min

Getting good feedback from our tests7 lectures • 30min

Mocking5 lectures • 19min

Designing for testability4 lectures • 13min

Engineering high-quality test code4 lectures • 12min

Other testing dilemmas6 lectures • 24min

Good bye!1 lecture • 1min

Requirements

Description

Who this course is for: