# Task

We’re nearing the **end** of this **course**, and to wrap up our **application**, I propose you **finish writing** all the **unit tests** for the **controller** and **service** layers.

# Task Explanation

**You need** to test **all the methods** in both the **controller** and **service** layers that **don’t yet have tests** written for them. For this, I **recommend** using `JUnit` along with the `Mockito` **library**.

# Test Writing Guidelines for JUnit

### Here are some key methods you'll find useful:

`assertNotNull(result)`: Ensures that the **result of a method** call is **not** `null`, confirming the operation was **successful**;

`assertEquals(expected, actual)`: Compares the **expected value** with the **actual value** to verify that the **correct data** is returned;

`assertTrue(condition)`: Checks that a **condition is true**, for example, ensuring a **list of books** is **empty** if there are **no records** in the database;

`verify(mock).methodCall()`: Verifies that a specific **method** on a **mock object** was called with the **expected parameters**, validating the **interaction** between components;

`when(mock.methodCall()).thenReturn(value)`: Configures a **mock to return** a certain **value** when a **method is called**, simulating **dependencies** in your **tests**.








## Controller Testing

Here, tests have already been **written** for the **methods** `findAllBooks`, `findByAuthor`, `createBook`, and `updateBook`. You'll **need** to write **tests** for the remaining **method**. Below are **some tips** to help you **implement** the test for **this method**.

### deleteBooks(String id)

For the `deleteBooks(String id)` **method**, you need to verify that the **delete method** is called with the **correct** `id` and test **error handling** when trying to **delete** a **non-existent** book. For a **successful response**, check only the **status**; for **errors**, verify both the **status** and **error message**.



QFRyYW5zYWN0aW9uYWwKcHVibGljIHZvaWQgZGVsZXRlQm9vayhTdHJpbmcgaWQpIHsKICAgIGlmKCFib29rUmVwb3NpdG9yeS5leGlzdHNCeUlkKGlkKSkgewogICAgICAgIHRocm93IG5ldyBBcGlFeGNlcHRpb24oIk5vdCBmb3VuZCBieSBpZDogIiArIGlkLCBIdHRwU3RhdHVzLk5PVF9GT1VORCk7CiAgICB9CiAgICBib29rUmVwb3NpdG9yeS5kZWxldGVCeUlkKGlkKTsKfQ==

**For the controller**, you will need to write **two tests** for this method: one for the **successful deletion** and **another** for when a `404 status` is **returned**.

**Keep in mind** that the **service method** we will be **mocking** returns **nothing**, just like the **controller**.

You can use the `doNothing()` **method** to stub a `void` **method**, ensuring **no actions** are performed upon its invocation. **The syntax is:**

```
doNothing().when(someService).someVoidMethod();
```


When you need to **handle a scenario** where an **exception** is thrown, use `doThrow()`. This method in `Mockito` **simulates** throwing an **exception** from a `void` method. **The syntax is:**

```
doThrow(new ApiException(messageException, HttpStatus.NOT_FOUND)).when(bookService).deleteBook("1");
```

## Service Testing

### deleteBook(String id)

The `deleteBook(String id)` **method** requires validation to **ensure** that the **book deletion** method is called with the **correct** `id`. Additionally, it is essential to **test** how the **method handles** the **situation** when a **book** with the specified `id` is **not found**.

You will need to **implement two tests**: one where the **entity** is found by `id` and **deleted**, and **another** where an **exception is thrown**.

# What If You Can’t Write Tests?

It’s **completely okay** if you **didn’t grasp** the **topic** on your **first attempt**; you might need to **read** through the **testing concepts** again. I also **recommend** reviewing the **solution** to this **assignment**.

This course covers key aspects of backend development on Spring Boot, including the basics of HTTP and Spring, designing and implementing RESTful APIs, working with relational databases, and testing applications. By the end of this course, users will have a solid understanding of backend development using Spring Boot, enabling them to design and implement robust RESTful APIs and manage data effectively with relational databases. They will also gain practical experience in testing applications, ensuring high-quality code and functionality.

You’ll learn the basics of backend development, including how the HTTP protocol works and the differences between HTTP and HTTPS. You’ll also study HTTP status codes and data formats like JSON and XML for transferring information between client and server.

In this section, we will dive into the essential concepts of backend development using Spring. We will cover various topics, including an introduction to Spring, the principles of Inversion of Control (IoC) and Dependency Injection (DI), the structure of a Spring Boot project, Spring MVC, three-tier architecture, and task management. Each chapter will build upon the previous one to provide a comprehensive understanding of backend development in a Spring environment.

This section covers the fundamentals and practical implementation of RESTful APIs, starting with the theoretical understanding of REST and its core principles. It also includes building your own API, working with DTOs, handling exceptions, integrating Swagger for documentation, and testing the API.

This section covers the basics of working with relational databases, including connection setup, migrations, and interaction with Object-Relational Mappers (ORM) using JPA and Hibernate. It discusses how to integrate databases with Spring Boot applications and explores key aspects of transaction management to ensure data integrity. The goal of this section is to enhance your database skills and promote their effective use in application development.

This section focuses on testing backend applications and covers essential topics such as the fundamentals of testing, unit testing using JUnit, and integration testing. It also explores the use of mock objects with the Mockito library to create effective and isolated tests. This section will help developers understand the importance of testing and learn how to utilize tools to enhance the quality and reliability of their applications.

Challenge: Unit Testing

Awesome!

Challenge: Unit Testing