Modern Software Testing

Modern Software Testing, available at $44.99, has an average rating of 4.3, with 37 lectures, based on 30 reviews, and has 860 subscribers.

You will learn about 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 This course is ideal for individuals who are Software developers that already know how to write tests, but want to get better at it! It is particularly useful for Software developers that already know how to write tests, but want to get better at it!.

Enroll now: Modern Software Testing

Summary

Title: Modern Software Testing

Price: $44.99

Average Rating: 4.3

Number of Lectures: 37

Number of Published Lectures: 37

Number of Curriculum Items: 37

Number of Published Curriculum Objects: 37

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

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

Target Audiences

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

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!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Welcome to this course!

Lecture 2: Test to guide development vs test to find bugs

Lecture 3: The laws of software testing

Chapter 2: Engineering strong tests

Lecture 1: What's engineering strong tests all about?

Lecture 2: Gut feeling testing vs systematic testing

Lecture 3: Being more systematic with domain testing

Lecture 4: Bugs love boundaries!

Lecture 5: Code coverage the right way!

Lecture 6: It's not about following a recipe!

Lecture 7: TDD: is it really magical? Should I do it?

Chapter 3: Getting good feedback from our tests

Lecture 1: What's good test feedback all about?

Lecture 2: Unit vs integration test: what matters is quality of feedback

Lecture 3: Simple and fast tests are better than slow and complex tests!

Lecture 4: I would have found this bug with e2e testing! No, you wouldn't!

Lecture 5: It's all about divide to conquer

Lecture 6: Focus on your use cases!

Lecture 7: You need testing infrastructure!

Chapter 4: Mocking

Lecture 1: Why do you want to mock in first place, and why you should want it!

Lecture 2: When to mock, when not to mock

Lecture 3: Internals vs peers: a nice way to classify mockable dependencies

Lecture 4: Stubs, fakes, and mocks: what's the difference?

Lecture 5: What's the main problem with mocks? What to pay attention to?

Chapter 5: Designing for testability

Lecture 1: Why is design for testability so important?

Lecture 2: Ports and adapters

Lecture 3: Controllability and observability

Lecture 4: Why are smaller classes better than large classes?

Chapter 6: Engineering high-quality test code

Lecture 1: Why do I care about test code quality?

Lecture 2: What makes a good test code?

Lecture 3: Tests without assertions, the biggest of the sins!

Lecture 4: Test code should look stupid!

Chapter 7: Other testing dilemmas

Lecture 1: The testing dilemmas never end!

Lecture 2: Flaky tests and how to avoid them

Lecture 3: Developers vs QA engineers

Lecture 4: How to test in a microservice world?

Lecture 5: Testing your legacy without having to refactor everything first

Lecture 6: What's mutation testing?

Chapter 8: Good bye!

Lecture 1: See you soon!

Instructors

Maurício Aniche
A software engineer passionate about software quality!

Rating Distribution

1 stars: 0 votes
2 stars: 0 votes
3 stars: 7 votes
4 stars: 11 votes
5 stars: 12 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu