Gain insights into building scalable applications with Thymeleaf and Spring Boot. Delve into Spring Data, Spring Security, and testing methods to ensure maintainable, portfolio-worthy projects.

maven.tar.gz

13SepBackgroundPostGres

DockerCompose14Sep

OptimizedMvn-22Sep

Moving into root - 24 Sep

From GitHub Repo - 12.4 - 24 Sep

Built from Github and running directly without watcher - 30Sep

Watcher - 29 Sep

From usercode directly - Oct 1

DockerCompose14Sep-Chapter09

OptimizedMvn-22Sep-Chapter11

DockerCompose14Sep-Chapter09-copy

Chapter09-Testing

Cypress

Chapter17-Testing

Cypress-copy

Integration Testing

Initial Chapters

Initial Chapters-copy

Watcher

Initial Chapters-Watcher

Integration Testing-copy

In this course, you will learn how to build easily scalable applications with Thymeleaf and Spring Boot. More specifically, you will combine Thymeleaf and Spring Boot with Spring Data and Spring Security. In a nutshell, this course will give you all the basics you need to start developing an application using Thymeleaf and Spring Boot.

Throughout the course, you will be building an application of a fictional basketball team called Thyme Wizards. Additionally, you will also learn to use unit and integration tests to ensure the proper code functionality and build a maintainable codebase that you can expand upon.

By the end, you will have a new project to add to your portfolio and some great new skills that employers will love.

Building Scalable Applications with Thymeleaf and Spring Boot

## Testing in Spring Boot

Spring Boot offers various utilities to start an application for testing, either fully or partially. We can use **`@SpringBootTest`** as a class annotation for a **JUnit test** which will start our complete application, including an embedded Tomcat to serve the HTML pages.

However, for tests that will only test a controller for example, we don’t need to start the full application.

Spring Boot has **test slices** that allows us to start, say, only the database layer (**`@DataJpaTest`**),  the web layer (**`@WebMvcTest`**), or the JSON converters (**`@JsonTest`**), etc.

## Using `@WebMvcTest`

We will use `@WebMvcTest` since it is the test slice we want for testing our `UserController`. The `@WebMvcTest` annotation will automatically configure a mock servlet environment. Using `MockMvc`, we can interact with our controller and validate requests and responses.

The following things will be created when using `@WebMvcTest`:

* All `@Controller` beans (or only a single one when specifying the class name on the `@WebMvcTest`
annotation).

* All `@ControllerAdvice` beans.

* All `@JsonComponent` beans, so custom JSON serializers and deserializers will be active.

* `org.springframework.core.convert.converter.Converter` beans.
* Filter beans.

* `WebMvcConfigurer` beans.

* `HandlerMethodArgumentResolver` beans.

* Spring Security configuration beans.

### What is not created?

* `@Component`

* `@Service`

* `@Repository`

* `@Configuration`

If our controller needs any of the above four, we should:

* add them by using `@Import`.

* add mock implementations by using `@MockBean`.

* use `@TestConfiguration` with `@Bean`.

## Why are we not doing plain unit tests for controllers?

You might wonder why we are immediately doing an integration test and not a plain unit test. In the case of a controller, there is quite a lot going on in terms of annotations interpreted by the Spring Framework and the security configuration of the application. Moreover, as a good rule of thumb, a controller should not contain much logic but should instead delegate to helper classes (Services and/or repositories). Given all that, the value of a plain unit test would be minimal.

# Testing in Spring Boot

Spring Boot offers various utilities to start an application for testing, either fully or partially. We can use **`@SpringBootTest`** as a class annotation for a **JUnit test** which will start our complete application, including an embedded Tomcat to serve the HTML pages.

However, for tests that will only test a controller for example, we don’t need to start the full application.

Spring Boot has **test slices** that allows us to start, say, only the database layer (**`@DataJpaTest`**),  the web layer (**`@WebMvcTest`**), or the JSON converters (**`@JsonTest`**), etc.

# Using `@WebMvcTest`

We will use `@WebMvcTest` since it is the test slice we want for testing our `UserController`. The `@WebMvcTest` annotation will automatically configure a mock servlet environment. Using `MockMvc`, we can interact with our controller and validate requests and responses.

The following things will be created when using `@WebMvcTest`:

* All `@Controller` beans (or only a single one when specifying the class name on the `@WebMvcTest`
annotation).

* All `@ControllerAdvice` beans.

* All `@JsonComponent` beans, so custom JSON serializers and deserializers will be active.

* `org.springframework.core.convert.converter.Converter` beans.
* Filter beans.

* `WebMvcConfigurer` beans.

* `HandlerMethodArgumentResolver` beans.

* Spring Security configuration beans.

## What is not created?

* `@Component`

* `@Service`

* `@Repository`

* `@Configuration`

If our controller needs any of the above four, we should:

* add them by using `@Import`.

* add mock implementations by using `@MockBean`.

* use `@TestConfiguration` with `@Bean`.

# Why are we not doing plain unit tests for controllers?

You might wonder why we are immediately doing an integration test and not a plain unit test. In the case of a controller, there is quite a lot going on in terms of annotations interpreted by the Spring Framework and the security configuration of the application. Moreover, as a good rule of thumb, a controller should not contain much logic but should instead delegate to helper classes (Services and/or repositories). Given all that, the value of a plain unit test would be minimal.

Get introduced to testing utilities in Spring Boot.

Introduction

Introduction to @WebMvcTest

Getting Started

What are Spring Boot and Thymeleaf?

Thymeleaf Introduction

Thyme Wizards

Fragments

Layouts

Controllers

Internationalization

Database Connection

Displaying Data

Forms

Data Editing

Implement Deletion of an Entity

Security

Security - Users from Database

Develop Microservices Using Spring Boot

Testing

Testing Using Cypress

Various Tips and Tricks - I

Various Tips and Tricks - II

Spring Boot and Thymeleaf Tutorial: Build a Recipe Sharing App

Conclusion

Appendix

Introduction to @WebMvcTest

Testing in Spring Boot