Learn to Write Less Test Code

(by working smarter, not harder)

Save time and money by writing less test code. If we select the right test cases and write our tests on the right level, we can write less test code without sacrificing our test coverage.
Write tests that embrace change. If we use the right techniques, we can write tests that don't tie our hands and slow us down when we make changes to our code.
Minimize the pain caused by integration and end-to-end tests. Writing these tests takes more work than writing unit tests, but we can use tools and techniques that minimize this overhead.

If you are struggling to write good automated tests, you are not alone

It's not easy to write good automated tests. It's a skill that requires years of work and often involves at least a few costly mistakes. To make matters worse, we are working in a constantly changing environment that doesn't necessarily appreciate (or support) our efforts to learn this skill.

Therefore, we often face these problems:

We don't have time to write automated tests because our managers pressure us to write new features.
Our requirements are changing constantly and our existing tests make this change harder.
We are dealing with legacy code that was not designed to be tested.
Configuring integration and end-to-end tests is too complicated.
Creating stable test data that doesn't require a lot of maintenance is too hard.

It's not impossible to learn the skills that help you to solve these problems, and you can do it on your own. However, it takes time that you don't most likely have.

Our biggest problem is not lack of effort. It is lack of time, and we cannot solve this problem by working harder because time is a very limited resource.

That is why we have to work smarter.

I have spend the last five years improving my testing skills, and I have written countless test cases. I have also rewritten too many of them because I wasn't working smarter. In other words, I learned my testing skills in the hard way.

About the author

Petri is specialized in automated testing and software development with the Spring Framework. He has written a book about Spring Data, and he writes a popular Java blog that has attracted over 1,2 million visitors in 2015.

If you choose to skip the painful learning process and leverage my hard earned testing skills, you can:

Save Both Time and Money by Writing Less Test Code

If you select the right test cases and write your tests on the right level, you can write less test code without sacrificing your test coverage.

Write Tests That Embrace Change and Don't Tie Your Hands

If you use the right techniques, you can write tests that don't tie your hands and slow you down when when you make changes to your code.

Minimize the Pain Caused by Integration and End-To-End Tests

Writing integration and end-to-end tests takes more work than writing unit tests, but you can use techniques that minimize this overhead.

My Journey From Zero to Hero

Five years ago I wrote a lot of automated tests. The problem was that I had only a vague idea what I was supposed to do. However, one thing that I did have was will to work hard. That turned out to be a bad thing.

My goal was to write good automated tests, but because I didn't fully understand what is a good test, I ended up writing a lot of them on autopilot. This lead into a maintenance nightmare.

After a while I had a lot of automated tests and the code coverage reports looked really good. However, I didn't have time to feel proud of myself, because I was too busy fixing my existing tests.

My test suite was suffering from these problems:

My unit tests had a lot of duplicate code and many of them were testing the same thing over and over again.
Maintaining the datasets of my integration tests took a lot of time because I had basically just copied them from another dataset.
Maintaining my end-to-end tests took too much time because even the slightest UI change broke them.

It was obvious that I wasn't doing a very good job.

I wanted to change, and I have spend the last five years improving my testing skills. I have written countless test cases, and I have also rewritten many of them after I learned a better way of doing things.

Because you are reading this page, the odds are that you don't want to spend the next five years learning these skills. You want a product that helps you to write good tests right now.

That is where I come in. I want to help you to skip the long learning process and to leverage my testing skills from day one.

What the Test With Spring Course does for you:

Get New Features Into Production Faster

The Test With Course helps you to create a balanced test suite which reduces development time with fast feedback (less debugging) and helps you catch bugs before you deploy your application into the production environment.

This means that you can get new features into production faster than before, these features have less bugs than before, and the bugs are fixed faster because they are found sooner than before.

In other words, you save both time and money.

Reduce Maintenance Costs

Maintenance consumes 40 to 80% of software's life cycle costs. That is a lot of money, and a good test suite will help you to spend less money on maintenance work because:

Good unit tests help you to write clean code that is easier to maintain.
A comprehensive test suite ensures that you write less bugs and spend less time running a debugger. In other words, you can make the required changes faster than before.

However, writing automated tests doesn't guarantee that you can enjoy from these benefits. A bad test suite will actually slow you down and increase your maintenance costs.

This course teaches you the skills that you need if you want to avoid this faith.

Keep Your Users Safe

Social media is a game changer. If you screw up, the whole world will hear about it, and this can destroy your reputation and your business.

Therefore, if you are not writing a toy application, it is in your best interest to ensure that:

The data that is processed by your application is correct.
The data of your users is safe. In other words, you must ensure that unauthorized users cannot access it.

Writing integration and end-to-end tests, which helps you to ensure these things, is tricky. However, the Test With Spring Course teaches you techniques that makes this process less painful.

You will learn how to write these tests faster without sacrificing the security of your users, your business, and your reputation.

What the Test With Spring Course teaches to you:

The Unit Testing module helps you to document your code, eliminate duplicate code, and write unit tests that embrace change. You will learn to:

Run unit tests by using Maven and Gradle.
Build test data in a less verbose way by using factory methods and test data builders.
Write clean assertions by using JUnit, Hamcrest, and AssertJ.
Create test doubles with less code by using Mockito and Java 8.
Make unit tests easier to read and maintain by leveraging the power of nested configuration.
Write unit tests for Spring web applications.

The Integration Testing module helps you to verify that your backend is working as expected and that unauthorized users cannot access the data of your users. You will learn to:

Run integration tests by using Maven and Gradle.
Create DbUnit datasets that are easy to read and maintain.
Write integration tests for Spring powered repositories.
Write integration tests for Spring web applications by using the Spring MVC Test framework.
Isolate the tested code from external systems and APIs.
Configure the application context of your application in a way that supports testing.

The End-to-End Testing module helps you to ensure that you don't deploy broken features into production and rewrite your tests when you make change to the UI. You will learn to:

Run end-to-end tests by using Maven and Gradle.
Verify that the migration scripts can create a working database.
Initialize the database into a known state before each test case.
Write end-to-end tests that are easy to fix when you make changes to the database.
Write end-to-end tests for a Javascript web application that has a Spring backend.
Write end-to-end tests for a normal Spring web application.

The Polyglot Testing module helps you to write to less code and transform your tests into executable specifications that can be read by domain experts. You will learn to:

Run Spock tests by using Maven and Gradle.
Write clean tests by leveraging the less verbose syntax of Groovy programming language.
Describe requirements by using plain English (or any other language)
Structure requirements by using nested configuration.
Visualize passing and failing requirements by creating an HTML test report.
Write unit, integration, and end-to-end tests with Spock Framework.

30 DAY MONEY BACK GUARANTEE

I have put a lot of effort for planning and creating the lessons of this course, and I am confident that you will be satisfied for it. That is why I will offer a 30 day money back guarantee.

If you are not satisfied, just contact support withing 30 days of your purchase and you will get your money back. No questions asked.

Take Your Testing Skills to the Next Level With the Test With Spring Course

The master package has not been released yet. However, you can pre-order the master package now and take advantage of the pre-order discount. This is a one time offer, and I will never offer new discounts after I have released the master package.

The deadline shown on the pricing table specify the date when all lessons of the master package are published. That being said, I will publish every lesson after it's done. In other words, you can watch them even if the entire package has not been released yet.

This course consists of the following packages:

Starter

One module:

Unit Testing

Study materials:

41 lessons
11 hours of video
Handouts
Example projects

$79

BUY

Master

Released 19th of November, 2017

Four Modules:

Unit Testing
Integration Testing
End-to-End Testing
Polyglot Testing

Study Materials:

110 lessons
Handouts
Example projects

A monthly webinar for the next 12 months after the purchase.

$299

$269

PRE-ORDER

Intermediate

Three modules:

Unit Testing
Integration Testing
End-to-End Testing