diff --git a/pom.xml b/pom.xml
index c42f36c..22a03b8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -130,7 +130,13 @@
 				<artifactId>jacoco-maven-plugin</artifactId>
 				<version>0.8.11</version>
 				<configuration>
-					<excludes>**/domain/**</excludes>
+					<excludes>
+						<exclude>**/springdoc/*</exclude>
+						<exclude>**/domain/**</exclude>
+						<exclude>**/infraestructure/security/SecurityConfigurations.class</exclude>
+						<exclude>**/AluraFlixApiApplication.class</exclude>
+						<exclude>**/infraestructure/security/SecurityFilter.class</exclude>
+					</excludes>
 				</configuration>
 				<executions>
 					<execution>
diff --git a/src/main/java/com/alura/aluraflixapi/controller/CategoryController.java b/src/main/java/com/alura/aluraflixapi/controller/CategoryController.java
index e336784..c635186 100644
--- a/src/main/java/com/alura/aluraflixapi/controller/CategoryController.java
+++ b/src/main/java/com/alura/aluraflixapi/controller/CategoryController.java
@@ -10,6 +10,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -67,10 +68,11 @@ public ResponseEntity<List<VideoDto>> getVideosByCategory(
   }
 
   @DeleteMapping(value = "/{id}", produces = "application/json")
+  @PreAuthorize("hasRole('Admin')")
   public ResponseEntity<HttpStatus> deleteCategory(@NotBlank @PathVariable final String id) {
     log.info("{} Request to Delete Category with Id: {}", PREFIX_LOGGING, id);
-    final var response = this.categoryService.deleteCategory(id);
-    return ResponseEntity.status(response).build();
+     this.categoryService.deleteCategory(id);
+    return ResponseEntity.ok().build();
   }
 
 }
diff --git a/src/main/java/com/alura/aluraflixapi/controller/ControllerAdvice.java b/src/main/java/com/alura/aluraflixapi/controller/ControllerAdvice.java
index 11a17e0..9961e5c 100644
--- a/src/main/java/com/alura/aluraflixapi/controller/ControllerAdvice.java
+++ b/src/main/java/com/alura/aluraflixapi/controller/ControllerAdvice.java
@@ -1,36 +1,34 @@
 package com.alura.aluraflixapi.controller;
 
-import com.alura.aluraflixapi.controller.dto.ErrorDto;
-import java.util.List;
+import com.alura.aluraflixapi.controller.dto.ErrorVO;
+import com.alura.aluraflixapi.infraestructure.exception.ErrorMessageVO;
+import com.alura.aluraflixapi.infraestructure.exception.ResourceNotFoundException;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
+import java.util.List;
+
 @RestControllerAdvice
 public class ControllerAdvice {
 
-  /**
-   * Handle Invalid fields
-   * @return List of ErrorDto with invalid fields
-   */
-  @ExceptionHandler(MethodArgumentNotValidException.class)
-  public ResponseEntity<List<ErrorDto>> handleInvalidFields(
-      final MethodArgumentNotValidException ex) {
-    var errors = ex.getFieldErrors();
-    return ResponseEntity.badRequest().body(errors.stream().map(ErrorDto::new).toList());
-  }
+    /**
+     * Handle Invalid fields
+     *
+     * @return List of ErrorDto with invalid fields
+     */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<List<ErrorVO>> handleInvalidFields(
+            final MethodArgumentNotValidException ex) {
+        var errors = ex.getFieldErrors();
+        return ResponseEntity.badRequest().body(errors.stream().map(ErrorVO::new).toList());
+    }
 
-  /**
-   * handle invalid credentials whe user atempt to login
-   * @param ex HttpMessageNotReadableException
-   * @return ResponseEntity status bad_request
-   */
-  @ExceptionHandler(HttpMessageNotReadableException.class)
-  public ResponseEntity<String> handleLoginException(
-      final HttpMessageNotReadableException ex) {
-    return ResponseEntity.badRequest().body("Invalid Credentials");
-  }
+    @ExceptionHandler(ResourceNotFoundException.class)
+    public ResponseEntity<ErrorMessageVO> handlerResourceNotFoundException(final ResourceNotFoundException ex) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorMessageVO(ex.getMessage(), HttpStatus.NOT_FOUND));
+    }
 
 }
diff --git a/src/main/java/com/alura/aluraflixapi/controller/UserController.java b/src/main/java/com/alura/aluraflixapi/controller/UserController.java
index aa1168d..3650554 100644
--- a/src/main/java/com/alura/aluraflixapi/controller/UserController.java
+++ b/src/main/java/com/alura/aluraflixapi/controller/UserController.java
@@ -3,37 +3,36 @@
 import com.alura.aluraflixapi.domain.user.dto.UserDto;
 import com.alura.aluraflixapi.infraestructure.service.UserService;
 import jakarta.validation.Valid;
-import java.util.List;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
-import org.springframework.security.access.annotation.Secured;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
 @Slf4j
 @RestController
 @RequestMapping("/user")
 public class UserController {
 
-  private static final String PREFIX_LOGGIN = "[UserController]";
+  private static final String PREFIX_LOGGING = "[UserController]";
+  private final UserService service;
 
-  @Autowired
-  private UserService service;
+  public UserController(UserService service) {
+    this.service = service;
+  }
 
   @PostMapping
-  @Secured("ROLE_ADMIN")
+  @PreAuthorize("hasRole('Admin')")
   public ResponseEntity<UserDto> saveUser(@RequestBody @Valid UserDto userDto) {
-    log.info("{} Saving new User: {}", PREFIX_LOGGIN, userDto.toString());
+    log.info("{} Saving new User: {}", PREFIX_LOGGING, userDto.toString());
     var newUser = this.service.saveUser(userDto);
     return ResponseEntity.ok().body(newUser);
   }
 
   @GetMapping
+  @PreAuthorize("hasRole('Admin')")
   public ResponseEntity<List<UserDto>> getUsers() {
-    log.info("{} Retrieving Users", PREFIX_LOGGIN);
+    log.info("{} Retrieving Users", PREFIX_LOGGING);
     var users = this.service.getUsers();
     return ResponseEntity.ok(users);
   }
diff --git a/src/main/java/com/alura/aluraflixapi/controller/VideoController.java b/src/main/java/com/alura/aluraflixapi/controller/VideoController.java
index 57f7157..6b829ab 100644
--- a/src/main/java/com/alura/aluraflixapi/controller/VideoController.java
+++ b/src/main/java/com/alura/aluraflixapi/controller/VideoController.java
@@ -7,16 +7,21 @@
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
+
 import java.util.List;
 import java.util.Optional;
+
 import lombok.extern.slf4j.Slf4j;
+import org.springdoc.core.annotations.ParameterObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.annotation.Secured;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -34,80 +39,75 @@
 @SecurityRequirement(name = "bearer-key")
 public class VideoController {
 
-  private static final String LOGGING_PREFIX = "[VideoController]";
+    private static final String LOGGING_PREFIX = "[VideoController]";
+
+    private final VideoService service;
+
+    @Autowired
+    public VideoController(final VideoService service) {
+        this.service = service;
+    }
+
+    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<Page<VideoDto>> getVideos(@ParameterObject Pageable pageable) {
+        log.info("{} Request to get All videos", LOGGING_PREFIX);
+        final Page<VideoDto> videos = this.service.getVideos(pageable);
+        log.info("{} Response {}: ", LOGGING_PREFIX, videos.getContent());
+        return ResponseEntity.ok().body(new PageImpl<>(videos.getContent(), pageable, pageable.getPageSize()));
+    }
+
 
-  private final VideoService service;
+    @GetMapping("/{id}")
+    public ResponseEntity<VideoDto> getById(@NotBlank @PathVariable final String id) {
+        log.info("{} Request to get a video by ID: {}", LOGGING_PREFIX, id);
+        return Optional.ofNullable(service.getById(id))
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
 
-  @Autowired
-  public VideoController(final VideoService service) {
-    this.service = service;
-  }
+    }
 
-  @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<Page<VideoDto>> getVideos(Pageable pageable) {
-    log.info("{} Request to get All videos", LOGGING_PREFIX);
-    final Page<VideoDto> videos = this.service.getVideos(pageable);
-    if (videos.hasContent()) {
-      log.info("{} Response {}: ", LOGGING_PREFIX, videos);
-      return ResponseEntity.ok().body(videos);
-    } else {
-      return ResponseEntity.noContent().build();
+    @PostMapping
+    public ResponseEntity<VideoDto> save(@Valid @RequestBody final VideoDto dto,
+                                         final UriComponentsBuilder uriBuilder) {
+        log.info("{} Request to Save a new video: {}", LOGGING_PREFIX, dto);
+        final VideoDto videoDto = this.service.save(dto);
+        //good practices to return the Location in the Header to be searched by Id
+        //return Http code 201 and Location with Id
+        return ResponseEntity.created(uriBuilder.path("/videos/{id}").buildAndExpand(videoDto.id())
+                .toUri()).body(videoDto);
     }
-  }
-
-
-  @GetMapping("/{id}")
-  public ResponseEntity<VideoDto> getById(@NotBlank @PathVariable final String id) {
-    log.info("{} Request to get a video by ID: {}", LOGGING_PREFIX, id);
-    return Optional.ofNullable(service.getById(id))
-        .map(ResponseEntity::ok)
-        .orElse(ResponseEntity.notFound().build());
-
-  }
-
-  @PostMapping
-  public ResponseEntity<VideoDto> save(@Valid @RequestBody final VideoDto dto,
-      final UriComponentsBuilder uriBuilder) {
-    log.info("{} Request to Save a new video: {}", LOGGING_PREFIX, dto);
-    final VideoDto videoDto = this.service.save(dto);
-    //good practices to return the Location in the Header to be search by Id
-    //return Http code 201 and Localtion with Id
-    return ResponseEntity.created(uriBuilder.path("/videos/{id}").buildAndExpand(videoDto.id())
-        .toUri()).body(videoDto);
-  }
-
-  @PutMapping
-  public ResponseEntity<UpdateVideoDto> update(@Valid @RequestBody final UpdateVideoDto dto,
-      final UriComponentsBuilder uriBuilder) {
-    log.info("{} Request to update a video: {}", LOGGING_PREFIX, dto);
-    final var videoDto = this.service.updateMovie(dto);
-    //good practices to return the Location in the Header to be search by Id
-    //return Http code 201 and Location with Id
-    return ResponseEntity.created(uriBuilder.path("/videos/{id}")
-        .buildAndExpand(videoDto.id())
-        .toUri()).body(videoDto);
-  }
-
-  @DeleteMapping("/{id}")
-  @Secured("ROLE_ADMIN")
-  public ResponseEntity<VideoDto> delete(@NotBlank @PathVariable final String id) {
-    log.info("{} Request to Delete a video by ID: {}", LOGGING_PREFIX, id);
-    final Optional<VideoDto> dto = this.service.delete(id);
-    return dto.map(videoDto -> ResponseEntity.status(HttpStatus.NO_CONTENT).body(videoDto))
-        .orElseGet(() -> ResponseEntity.noContent().build());
-  }
-
-  @GetMapping("/title")
-  public ResponseEntity<List<VideoDto>> getVideosByTitle(
-      @NotBlank @RequestParam("title") final String title) {
-    log.info("{} Request to get a video by title: {}", LOGGING_PREFIX, title);
-    final var videosByTitle = this.service.getVideosByTitle(title);
-    if (videosByTitle.isEmpty()) {
-      return ResponseEntity.noContent().build();
-    } else {
-      return ResponseEntity.status(HttpStatus.FOUND).body(videosByTitle);
+
+    @PutMapping
+    public ResponseEntity<UpdateVideoDto> update(@Valid @RequestBody final UpdateVideoDto dto,
+                                                 final UriComponentsBuilder uriBuilder) {
+        log.info("{} Request to update a video: {}", LOGGING_PREFIX, dto);
+        final var videoDto = this.service.updateMovie(dto);
+        //good practices to return the Location in the Header to be search by Id
+        //return Http code 201 and Location with Id
+        return ResponseEntity.created(uriBuilder.path("/videos/{id}")
+                .buildAndExpand(videoDto.id())
+                .toUri()).body(videoDto);
     }
 
-  }
+    @DeleteMapping("/{id}")
+    @PreAuthorize("hasRole('Admin')")
+    public ResponseEntity<VideoDto> delete(@NotBlank @PathVariable final String id) {
+        log.info("{} Request to Delete a video by ID: {}", LOGGING_PREFIX, id);
+        final var dto = this.service.delete(id);
+        return ResponseEntity.ok(dto);
+    }
+
+    @GetMapping("/title")
+    public ResponseEntity<List<VideoDto>> getVideosByTitle(
+            @NotBlank @RequestParam("title") final String title) {
+        log.info("{} Request to get a video by title: {}", LOGGING_PREFIX, title);
+        final var videosByTitle = this.service.getVideosByTitle(title);
+        if (videosByTitle.isEmpty()) {
+            return ResponseEntity.noContent().build();
+        } else {
+            return ResponseEntity.status(HttpStatus.FOUND).body(videosByTitle);
+        }
+
+    }
 
 }
diff --git a/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorDto.java b/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorDto.java
deleted file mode 100644
index d1d2af4..0000000
--- a/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorDto.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.alura.aluraflixapi.controller.dto;
-
-import org.springframework.validation.FieldError;
-
-public record ErrorDto(String field, String message) {
-
-  public ErrorDto(FieldError fieldError) {
-    this(fieldError.getField(), fieldError.getDefaultMessage());
-  }
-
-}
diff --git a/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorVO.java b/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorVO.java
new file mode 100644
index 0000000..22f1f22
--- /dev/null
+++ b/src/main/java/com/alura/aluraflixapi/controller/dto/ErrorVO.java
@@ -0,0 +1,10 @@
+package com.alura.aluraflixapi.controller.dto;
+
+import org.springframework.validation.FieldError;
+
+public record ErrorVO(String field, String message) {
+
+    public ErrorVO(FieldError fieldError) {
+        this(fieldError.getField(), fieldError.getDefaultMessage());
+    }
+}
diff --git a/src/main/java/com/alura/aluraflixapi/domain/user/User.java b/src/main/java/com/alura/aluraflixapi/domain/user/User.java
index 0fadb14..7991394 100644
--- a/src/main/java/com/alura/aluraflixapi/domain/user/User.java
+++ b/src/main/java/com/alura/aluraflixapi/domain/user/User.java
@@ -6,6 +6,8 @@
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.List;
+import java.util.Set;
+
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.EqualsAndHashCode;
@@ -39,7 +41,7 @@ public class User implements Serializable, UserDetails {
   private String password;
 
   @DBRef
-  private List<Roles> roles;
+  private Set<Roles> roles;
 
   @Override
   public Collection<? extends GrantedAuthority> getAuthorities() {
diff --git a/src/main/java/com/alura/aluraflixapi/domain/user/dto/UserDto.java b/src/main/java/com/alura/aluraflixapi/domain/user/dto/UserDto.java
index 162ae12..f011e8c 100644
--- a/src/main/java/com/alura/aluraflixapi/domain/user/dto/UserDto.java
+++ b/src/main/java/com/alura/aluraflixapi/domain/user/dto/UserDto.java
@@ -2,7 +2,8 @@
 
 import com.alura.aluraflixapi.domain.user.roles.Roles;
 import jakarta.validation.constraints.NotBlank;
-import java.util.List;
+
+import java.util.Set;
 
 public record UserDto(
     String id,
@@ -10,6 +11,6 @@ public record UserDto(
     String username,
     @NotBlank
     String password,
-    List<Roles> roles) {
+    Set<Roles> roles) {
 
 }
diff --git a/src/main/java/com/alura/aluraflixapi/domain/video/dto/VideoDto.java b/src/main/java/com/alura/aluraflixapi/domain/video/dto/VideoDto.java
index 1144eef..137ad8a 100644
--- a/src/main/java/com/alura/aluraflixapi/domain/video/dto/VideoDto.java
+++ b/src/main/java/com/alura/aluraflixapi/domain/video/dto/VideoDto.java
@@ -3,10 +3,8 @@
 import com.alura.aluraflixapi.domain.category.dto.CategoryDto;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
-import lombok.Builder;
 import org.hibernate.validator.constraints.URL;
 
-@Builder
 public record VideoDto(
     String id,
     @NotBlank
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryServiceException.java b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryServiceException.java
new file mode 100644
index 0000000..487be52
--- /dev/null
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryServiceException.java
@@ -0,0 +1,11 @@
+package com.alura.aluraflixapi.infraestructure.exception;
+
+public class CategoryServiceException extends RuntimeException {
+    public CategoryServiceException(String message) {
+        super(message);
+    }
+
+    public CategoryServiceException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryTransactionException.java b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryTransactionException.java
deleted file mode 100644
index 65a6772..0000000
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/CategoryTransactionException.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.alura.aluraflixapi.infraestructure.exception;
-
-public class CategoryTransactionException extends RuntimeException {
-
-  public CategoryTransactionException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ErrorMessageVO.java b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ErrorMessageVO.java
new file mode 100644
index 0000000..c6015ce
--- /dev/null
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ErrorMessageVO.java
@@ -0,0 +1,6 @@
+package com.alura.aluraflixapi.infraestructure.exception;
+
+import org.springframework.http.HttpStatus;
+
+public record ErrorMessageVO(String message, HttpStatus httpStatus) {
+}
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ResourceNotFoundException.java b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ResourceNotFoundException.java
new file mode 100644
index 0000000..32ff49a
--- /dev/null
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/ResourceNotFoundException.java
@@ -0,0 +1,7 @@
+package com.alura.aluraflixapi.infraestructure.exception;
+
+public class ResourceNotFoundException extends RuntimeException {
+    public ResourceNotFoundException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/exception/VideoServiceException.java b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/VideoServiceException.java
new file mode 100644
index 0000000..6513451
--- /dev/null
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/exception/VideoServiceException.java
@@ -0,0 +1,12 @@
+package com.alura.aluraflixapi.infraestructure.exception;
+
+public class VideoServiceException extends RuntimeException {
+
+    public VideoServiceException(String message) {
+        super(message);
+    }
+
+    public VideoServiceException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/mapper/UserMapper.java b/src/main/java/com/alura/aluraflixapi/infraestructure/mapper/UserMapper.java
index 39a6927..2b3dcf0 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/mapper/UserMapper.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/mapper/UserMapper.java
@@ -12,11 +12,11 @@
 public interface UserMapper {
 
   @Mapping(target = "password", qualifiedByName = "encryptPassword")
-  User mappToEntity(UserDto dto);
+  User mapToEntity(UserDto dto);
 
-  UserDto mappToDto(User newUser);
+  UserDto mapToDto(User newUser);
 
-  List<UserDto> mappToUsersDto(List<User> users);
+  List<UserDto> mapToUsersDto(List<User> users);
 
 
   @Named("encryptPassword")
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/repository/UserRepository.java b/src/main/java/com/alura/aluraflixapi/infraestructure/repository/UserRepository.java
index 0c24b17..0082d5f 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/repository/UserRepository.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/repository/UserRepository.java
@@ -6,6 +6,5 @@
 
 
 public interface UserRepository extends MongoRepository<User, String> {
-
-  UserDetails findByUsername(String username);
+    UserDetails findByUsername(String username);
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityConfigurations.java b/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityConfigurations.java
index 8cb037f..390feed 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityConfigurations.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityConfigurations.java
@@ -9,18 +9,11 @@
 import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
-import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
-import org.springframework.web.cors.CorsConfiguration;
-import org.springframework.web.cors.CorsConfigurationSource;
-import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
-
-import java.util.Arrays;
-import java.util.List;
 
 /**
  * Main Spring Security class configuration In Spring 3.0 the security configuration is done by
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityFilter.java b/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityFilter.java
index d559b86..e82f01b 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityFilter.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/security/SecurityFilter.java
@@ -23,7 +23,6 @@ public class SecurityFilter extends OncePerRequestFilter {
   private static final String PREFIX_LOGGING = "[SecurityFilter]";
   public static final String AUTHORIZATION = "Authorization";
   private final TokenService tokenService;
-
   private final UserRepository userRepository;
 
   public SecurityFilter(final TokenService tokenService, final UserRepository userRepository) {
@@ -43,8 +42,8 @@ protected void doFilterInternal(final HttpServletRequest request,
 
     if (tokenJWT != null) {
       //Retrieve user from Token JWT
-      final var subject = tokenService.getSubject(tokenJWT);
-      var user = userRepository.findByUsername(subject);
+      final var subject = this.tokenService.getSubject(tokenJWT);
+      var user = this.userRepository.findByUsername(subject);
 
       //after retrieve the user we need to tell to Spring framework to authenticate him in the context
       //this is done by calling UsernamePasswordAuthenticationToken and SecurityContextHolder methods
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/security/TokenService.java b/src/main/java/com/alura/aluraflixapi/infraestructure/security/TokenService.java
index df966cd..7ac0640 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/security/TokenService.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/security/TokenService.java
@@ -9,6 +9,8 @@
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneOffset;
+
+import com.auth0.jwt.exceptions.JWTDecodeException;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
@@ -24,7 +26,7 @@ public class TokenService {
 
   public String generateTokenJWT(User user) {
     try {
-      log.info("Generating JWt Token...");
+      log.info("Generating Token JWT ...");
       return JWT.create()
           .withIssuer(ALURA_FLIX_API)
           //owner
@@ -39,7 +41,7 @@ public String generateTokenJWT(User user) {
           .withExpiresAt(getExpireDate())
           .sign(Algorithm.HMAC256(secret));
 
-    } catch (JWTCreationException exception) {
+    } catch (NullPointerException exception) {
       throw new JWTCreationException("Error to create JWT token", exception.getCause());
     }
   }
@@ -52,8 +54,8 @@ public String getSubject(String tokenJWT) {
           .build()
           .verify(tokenJWT)
           .getSubject();
-    } catch (JWTCreationException ex) {
-      throw new JWTCreationException("Error verifying JWT Token", ex.getCause());
+    } catch (JWTDecodeException ex) {
+      throw new JWTDecodeException("Error verifying JWT Token", ex.getCause());
     }
 
   }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryService.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryService.java
index ec3a7f9..ee32c34 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryService.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryService.java
@@ -13,7 +13,7 @@ public interface CategoryService {
 
   CategoryDto findCategoryById(String id);
 
-  HttpStatus deleteCategory(String id);
+  void deleteCategory(String id);
 
   List<VideoDto> getVideosByCategory(String rating);
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImpl.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImpl.java
index dfe2fae..cf3df29 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImpl.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImpl.java
@@ -2,12 +2,14 @@
 
 import com.alura.aluraflixapi.domain.category.dto.CategoryDto;
 import com.alura.aluraflixapi.domain.video.dto.VideoDto;
-import com.alura.aluraflixapi.infraestructure.exception.CategoryTransactionException;
+import com.alura.aluraflixapi.infraestructure.exception.CategoryServiceException;
 import com.alura.aluraflixapi.infraestructure.mapper.CategoryMapper;
 import com.alura.aluraflixapi.infraestructure.mapper.VideoMapper;
 import com.alura.aluraflixapi.infraestructure.repository.CategoryRepository;
 import com.alura.aluraflixapi.infraestructure.repository.VideoRepository;
+
 import java.util.List;
+
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.mongodb.MongoTransactionException;
 import org.springframework.http.HttpStatus;
@@ -19,71 +21,70 @@
 public class CategoryServiceImpl implements CategoryService {
 
 
-  private final CategoryRepository categoryRepository;
+    private final CategoryRepository categoryRepository;
+
+    private final VideoRepository videoRepository;
 
-  private final VideoRepository videoRepository;
+    private final VideoMapper videoMapper;
 
-  private final VideoMapper videoMapper;
+    private final CategoryMapper categoryMapper;
 
-  private final CategoryMapper categoryMapper;
 
+    public CategoryServiceImpl(CategoryRepository categoryRepository, VideoRepository videoRepository,
+                               VideoMapper videoMapper, CategoryMapper categoryMapper) {
+        this.categoryRepository = categoryRepository;
+        this.videoRepository = videoRepository;
+        this.videoMapper = videoMapper;
+        this.categoryMapper = categoryMapper;
+    }
 
-  public CategoryServiceImpl(CategoryRepository categoryRepository, VideoRepository videoRepository,
-      VideoMapper videoMapper, CategoryMapper categoryMapper) {
-    this.categoryRepository = categoryRepository;
-    this.videoRepository = videoRepository;
-    this.videoMapper = videoMapper;
-    this.categoryMapper = categoryMapper;
-  }
+    @Override
+    public List<CategoryDto> categories() {
+        return categoryRepository.findAll()
+                .stream()
+                .map(entity -> new CategoryDto(entity.getId(), entity.getRating(), entity.getTitle(),
+                        entity.getColorHex()))
+                .toList();
+    }
 
-  @Override
-  public List<CategoryDto> categories() {
-    return categoryRepository.findAll()
-        .stream()
-        .map(entity -> new CategoryDto(entity.getId(), entity.getRating(), entity.getTitle(),
-            entity.getColorHex()))
-        .toList();
-  }
+    @Override
+    @Transactional
+    public CategoryDto create(CategoryDto categoryDto) {
+        try {
+            final var entity = this.categoryMapper.mapperToEntity(categoryDto);
+            final var categorySaved = categoryRepository.save(entity);
+            return this.categoryMapper.mapperToCategoryDto(categorySaved);
+        } catch (MongoTransactionException exception) {
+            throw new CategoryServiceException("Error to persist new category",
+                    exception.getMostSpecificCause());
+        }
+    }
 
-  @Override
-  @Transactional
-  public CategoryDto create(CategoryDto categoryDto) {
-    try {
-      final var entity = this.categoryMapper.mapperToEntity(categoryDto);
-      final var categorySaved = categoryRepository.save(entity);
-      return this.categoryMapper.mapperToCategoryDto(categorySaved);
-    } catch (MongoTransactionException exception) {
-      throw new CategoryTransactionException("Error to persist new category",
-          exception.getMostSpecificCause());
+    @Override
+    public CategoryDto findCategoryById(String id) {
+        return this.categoryRepository.findById(id)
+                .map(
+                        document -> new CategoryDto(document.getId(), document.getRating(), document.getTitle(),
+                                document.getColorHex()))
+                .orElseThrow(() -> new CategoryServiceException("Category not found: " + id));
     }
-  }
-
-  @Override
-  public CategoryDto findCategoryById(String id) {
-    return this.categoryRepository.findById(id)
-        .map(
-            document -> new CategoryDto(document.getId(), document.getRating(), document.getTitle(),
-                document.getColorHex()))
-        .orElse(null);
-  }
-
-  @Override
-  @Transactional
-  public HttpStatus deleteCategory(String id) {
-    try {
-      this.categoryRepository.deleteById(id);
-      return HttpStatus.ACCEPTED;
-    } catch (MongoTransactionException exception) {
-      log.error("Error", exception.getCause());
-      return HttpStatus.NO_CONTENT;
+
+    @Override
+    @Transactional
+    public void deleteCategory(String id) {
+
+        final var isCategoryPresent = this.categoryRepository.findById(id);
+        isCategoryPresent.ifPresentOrElse(this.categoryRepository::delete, () -> {
+            throw new CategoryServiceException("Category not found to delete with Id:" + id);
+        });
+
+    }
+
+    @Override
+    public List<VideoDto> getVideosByCategory(String rating) {
+        final var category = categoryRepository.findCategoryByRating(rating);
+        return videoRepository.findVideosByCategories(category.getId())
+                .stream().map(this.videoMapper::mapToVideoDto)
+                .toList();
     }
-  }
-
-  @Override
-  public List<VideoDto> getVideosByCategory(String rating) {
-    final var category = categoryRepository.findCategoryByRating(rating);
-    return videoRepository.findVideosByCategories(category.getId())
-        .stream().map(this.videoMapper::mapToVideoDto)
-        .toList();
-  }
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImpl.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImpl.java
index 6fc96aa..1561047 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImpl.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImpl.java
@@ -2,12 +2,15 @@
 
 import com.alura.aluraflixapi.infraestructure.repository.UserRepository;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.core.userdetails.UsernameNotFoundException;
 import org.springframework.stereotype.Service;
 
+import java.util.Objects;
+
 /**
  * User Details Service Impl that connect to database and retrieve a user previously registred
  */
@@ -15,24 +18,29 @@
 @Service
 public class UserDetailsServiceImpl implements UserDetailsService {
 
-  private static final String PREFIX_LOGGING = "[UserDetailsServiceImpl]";
+    private static final String PREFIX_LOGGING = "[UserDetailsServiceImpl]";
 
-  private final UserRepository repository;
+    private final UserRepository repository;
 
-  @Autowired
-  public UserDetailsServiceImpl(UserRepository repository) {
-    this.repository = repository;
-  }
+    @Autowired
+    public UserDetailsServiceImpl(UserRepository repository) {
+        this.repository = repository;
+    }
 
-  /**
-   * Search in databse a user by username and return it
-   * @return UserDestails
-   */
-  @Override
-  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
-    log.info("{} Retrieving User by username: {}", PREFIX_LOGGING, username);
-    final var user = this.repository.findByUsername(username);
-    log.info("{} Retrieved User: {}", PREFIX_LOGGING, user);
-    return user;
-  }
+    /**
+     * Search in databse a user by username and return it
+     *
+     * @return UserDestails
+     */
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        log.info("{} Retrieving User by username: {}", PREFIX_LOGGING, username);
+        final var user = this.repository.findByUsername(username);
+        log.info("{} Retrieved User: {}", PREFIX_LOGGING, user);
+        if (Objects.isNull(user)) {
+            throw new UsernameNotFoundException(String.format("User not found for: %s", username));
+        } else {
+            return user;
+        }
+    }
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImpl.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImpl.java
index d87f2ba..619172d 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImpl.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImpl.java
@@ -26,17 +26,17 @@ public UserServiceImpl(final UserRepository repository, final RoleRepository rol
 
   @Override
   public UserDto saveUser(UserDto dto) {
-    final User user = mapper.mappToEntity(dto);
+    final User user = mapper.mapToEntity(dto);
     //first save Document Roles
     this.roleRepository.saveAll(dto.roles());
     //After save Document User
     final User newUser = repository.save(user);
-    return mapper.mappToDto(newUser);
+    return mapper.mapToDto(newUser);
   }
 
   @Override
   public List<UserDto> getUsers() {
     List<User> users = repository.findAll();
-    return mapper.mappToUsersDto(users);
+    return mapper.mapToUsersDto(users);
   }
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoService.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoService.java
index bebed39..f80370e 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoService.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoService.java
@@ -17,7 +17,7 @@ public interface VideoService {
 
   UpdateVideoDto updateMovie(UpdateVideoDto dto);
 
-  Optional<VideoDto> delete(String id);
+  VideoDto delete(String id);
 
   VideoDto getById(String id);
 
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImpl.java b/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImpl.java
index 646649d..fe98a4e 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImpl.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImpl.java
@@ -6,6 +6,8 @@
 import com.alura.aluraflixapi.domain.video.Video;
 import com.alura.aluraflixapi.domain.video.dto.UpdateVideoDto;
 import com.alura.aluraflixapi.domain.video.dto.VideoDto;
+import com.alura.aluraflixapi.infraestructure.exception.ResourceNotFoundException;
+import com.alura.aluraflixapi.infraestructure.exception.VideoServiceException;
 import com.alura.aluraflixapi.infraestructure.mapper.VideoMapper;
 import com.alura.aluraflixapi.infraestructure.repository.CategoryRepository;
 import com.alura.aluraflixapi.infraestructure.repository.VideoRepository;
@@ -19,6 +21,7 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -46,10 +49,10 @@ public Page<VideoDto> getVideos(Pageable pageable) {
                 .forEach(video -> {
                     if (Objects.isNull(video.getCategory())) {
                         video.setCategory(Category.builder()
-                                .id(null)
+                                .id("")
                                 .rating(Rating.FREE.name())
-                                .title(null)
-                                .colorHex(null)
+                                .title("")
+                                .colorHex("")
                                 .build());
                     }
                 });
@@ -66,7 +69,7 @@ public VideoDto save(VideoDto dto) {
             log.info("{} New Video saved", LOGGING_PREFIX);
             return videoMapper.mapToVideoDto(entityPersisted);
         } catch (Exception e) {
-            throw new RuntimeException("Error to persist entity", e.getCause());
+            throw new VideoServiceException("Error to persist entity", e.getCause());
         }
     }
 
@@ -81,30 +84,39 @@ public UpdateVideoDto updateMovie(UpdateVideoDto dto) {
             videoRepository.save(entity);
             return videoMapper.mapToUpdateVideoDto(entity);
         } catch (Exception e) {
-            throw new RuntimeException("Error to update movie", e.getCause());
+            throw new VideoServiceException("Error to update movie", e.getCause());
         }
 
     }
 
     @Override
-    public Optional<VideoDto> delete(String id) {
-        Optional<Video> entityToDelete = videoRepository.findById(id);
-        entityToDelete.ifPresent(this.videoRepository::delete);
-        return entityToDelete.map(videoMapper::mapToVideoDto);
+    public VideoDto delete(String id) {
+        final var entity = videoRepository.findById(id);
+        if (entity.isPresent()) {
+            this.videoRepository.delete(entity.get());
+            return this.videoMapper.mapToVideoDto(entity.get());
+        } else {
+            throw new ResourceNotFoundException("Resource not found: " + id);
+        }
     }
 
     @Override
     public VideoDto getById(String id) {
         return videoRepository.findById(id)
                 .map(videoMapper::mapToVideoDto)
-                .orElse(null);
+                .orElseThrow(() -> new ResourceNotFoundException("Resource not found for id: " + id));
     }
 
     @Override
     public List<VideoDto> getVideosByTitle(String name) {
-        return this.videoRepository.findByTitleLike(name)
+        final var videos = videoRepository.findByTitleLike(name)
                 .stream()
                 .map(this.videoMapper::mapToVideoDto)
                 .toList();
+        if (videos.isEmpty()) {
+            throw new ResourceNotFoundException("Video not found with title: " + name);
+        } else {
+            return videos;
+        }
     }
 }
diff --git a/src/main/java/com/alura/aluraflixapi/infraestructure/springdoc/SpringdocConfiguration.java b/src/main/java/com/alura/aluraflixapi/infraestructure/springdoc/SpringdocConfiguration.java
index 27b3cc7..666a8b4 100644
--- a/src/main/java/com/alura/aluraflixapi/infraestructure/springdoc/SpringdocConfiguration.java
+++ b/src/main/java/com/alura/aluraflixapi/infraestructure/springdoc/SpringdocConfiguration.java
@@ -13,7 +13,7 @@
 
 @Configuration
 //Necessary because Swagger sends requests in HTTP
-@OpenAPIDefinition(servers = @Server(url = "https://alura-flix-api-production.up.railway.app"))
+@OpenAPIDefinition(servers = @Server(url = "/", description = "Default server"))
 public class SpringdocConfiguration {
     @Bean
     public OpenAPI customOpenAPI() {
diff --git a/src/test/java/com/alura/aluraflixapi/controller/AuthenticationControllerTest.java b/src/test/java/com/alura/aluraflixapi/controller/AuthenticationControllerTest.java
index fbf709a..bfc0de0 100644
--- a/src/test/java/com/alura/aluraflixapi/controller/AuthenticationControllerTest.java
+++ b/src/test/java/com/alura/aluraflixapi/controller/AuthenticationControllerTest.java
@@ -15,6 +15,7 @@
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -38,7 +39,8 @@ void login_test() {
         //Given
         final var tokenJwtFake = UUID.randomUUID().toString();
         final var userAdministrator = new User("1", "admin@aluraflix.com", "administrator",
-                List.of(Roles.builder().id("1").role(RolesEnum.ROLE_ADMIN).build()));
+                Set.of(Roles.builder().id("1").role(RolesEnum.ROLE_ADMIN).build()));
+
         final var testingAuthenticationToken = new TestingAuthenticationToken(userAdministrator, userAdministrator);
         when(this.tokenService.generateTokenJWT(Mockito.any())).thenReturn(tokenJwtFake);
         when(this.manager.authenticate(Mockito.any())).thenReturn(testingAuthenticationToken);
diff --git a/src/test/java/com/alura/aluraflixapi/controller/CategoryControllerTest.java b/src/test/java/com/alura/aluraflixapi/controller/CategoryControllerTest.java
index 9895177..1976f21 100644
--- a/src/test/java/com/alura/aluraflixapi/controller/CategoryControllerTest.java
+++ b/src/test/java/com/alura/aluraflixapi/controller/CategoryControllerTest.java
@@ -179,12 +179,11 @@ void getVideosByCategory_return_no_content_test() throws Exception {
     @Test
     void deleteCategory_test() throws Exception {
         //Given
-        when(this.categoryService.deleteCategory(anyString())).thenReturn(HttpStatus.ACCEPTED);
         //The
         this.mockMvc.perform(MockMvcRequestBuilders.delete("/category/{id}", "63f67ec16295ed744dd460cd")
                         .with(SecurityMockMvcRequestPostProcessors.csrf().asHeader())
                         .accept(MediaType.APPLICATION_JSON))
                 .andDo(MockMvcResultHandlers.print())
-                .andExpect(status().isAccepted());
+                .andExpect(status().is2xxSuccessful());
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/controller/ControllerAdviceTest.java b/src/test/java/com/alura/aluraflixapi/controller/ControllerAdviceTest.java
new file mode 100644
index 0000000..eaa679e
--- /dev/null
+++ b/src/test/java/com/alura/aluraflixapi/controller/ControllerAdviceTest.java
@@ -0,0 +1,112 @@
+package com.alura.aluraflixapi.controller;
+
+import com.alura.aluraflixapi.controller.dto.ErrorVO;
+import com.alura.aluraflixapi.domain.video.dto.VideoDto;
+import com.alura.aluraflixapi.infraestructure.exception.ErrorMessageVO;
+import com.alura.aluraflixapi.infraestructure.exception.ResourceNotFoundException;
+import com.alura.aluraflixapi.infraestructure.repository.UserRepository;
+import com.alura.aluraflixapi.infraestructure.security.TokenService;
+import com.alura.aluraflixapi.infraestructure.service.CategoryService;
+import com.alura.aluraflixapi.infraestructure.service.UserService;
+import com.alura.aluraflixapi.infraestructure.service.VideoService;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@WebMvcTest
+@WithMockUser(value = "admin", username = "admin", password = "admin", roles = "ADMIN")
+class ControllerAdviceTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+    private static ObjectMapper objectMapper;
+
+    @MockBean
+    private AuthenticationController authenticationController;
+
+    @MockBean
+    private CategoryService categoryService;
+
+    @MockBean
+    private UserService userService;
+
+    @MockBean
+    private VideoService videoService;
+
+    @MockBean
+    private TokenService tokenService;
+
+    @MockBean
+    private UserRepository UserRepository;
+
+    @BeforeEach
+    void setup() {
+        objectMapper = new ObjectMapper();
+    }
+
+    @Test
+    @DisplayName("Should return a ErrorDto with the missing fields and response status 400")
+    void handleInvalidFields_test() throws Exception {
+        //Given
+        final var request = new VideoDto(UUID.randomUUID().toString(), "Lord of the rings",
+                "The lord of the rings - The Fellowship of the ring", "www.thelordoftherings.com", null);
+        //When
+        final var response = this.mockMvc.perform(MockMvcRequestBuilders.post("/videos")
+                        .with(SecurityMockMvcRequestPostProcessors.csrf().asHeader())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsBytes(request))
+                )
+                .andExpect(status().is4xxClientError())
+                .andDo(MockMvcResultHandlers.print())
+                .andReturn();
+
+        //Then
+        final var errors = objectMapper.readValue(response.getResponse().getContentAsString(), new TypeReference<List<ErrorVO>>() {
+        });
+        assertThat(errors)
+                .hasSize(2)
+                .isNotNull();
+
+    }
+
+    @Test
+    void handlerResourceNotFoundException_test() throws Exception {
+        when(this.videoService.getById(anyString()))
+                .thenThrow(new ResourceNotFoundException("Resource not found for id: 1"));
+        //When
+        final var response = this.mockMvc.perform(MockMvcRequestBuilders.get("/videos/{id}", "1")
+                        .with(SecurityMockMvcRequestPostProcessors.csrf().asHeader())
+                        .accept(MediaType.APPLICATION_JSON)
+                ).andExpect(status().isNotFound())
+                .andDo(print())
+                .andReturn();
+
+        //Then
+        final var errorMessageVO = objectMapper.readValue(response.getResponse().getContentAsString(), ErrorMessageVO.class);
+        Assertions.assertThat(errorMessageVO.message())
+                .isNotNull()
+                .isEqualTo("Resource not found for id: 1");
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/controller/UserControllerTest.java b/src/test/java/com/alura/aluraflixapi/controller/UserControllerTest.java
new file mode 100644
index 0000000..ea5f2d5
--- /dev/null
+++ b/src/test/java/com/alura/aluraflixapi/controller/UserControllerTest.java
@@ -0,0 +1,73 @@
+package com.alura.aluraflixapi.controller;
+
+import com.alura.aluraflixapi.domain.user.dto.UserDto;
+import com.alura.aluraflixapi.domain.user.roles.Roles;
+import com.alura.aluraflixapi.domain.user.roles.RolesEnum;
+import com.alura.aluraflixapi.infraestructure.service.UserService;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(SpringExtension.class)
+class UserControllerTest {
+
+    @MockBean
+    private UserService userService;
+
+    @SpyBean
+    private UserController userController;
+
+    @Test
+    @DisplayName("Should save a new user and response 200 OK")
+    void saveUser_test() {
+        //Given
+        final var userId = UUID.randomUUID().toString();
+        final var roleId = UUID.randomUUID().toString();
+        final var user = new UserDto(userId, "guest@aluraflix.com.br", "123456",
+                Set.of(Roles.builder()
+                .id(roleId)
+                .role(RolesEnum.ROLE_GUEST).build()));
+        when(this.userService.saveUser(any())).thenReturn(user);
+
+        //When
+        final var response = this.userController.saveUser(user);
+
+        //Then
+        assertThat(response).isNotNull();
+        assertThat(user).usingRecursiveComparison().isEqualTo(response.getBody());
+    }
+
+    @Test
+    @DisplayName("Should return a list of users and response 200 OK")
+    void getUsers_test() {
+        //Given
+        final var usersList = List.of(new UserDto(UUID.randomUUID().toString(), "guest@aluraflix.com.br", "123456",
+                        Set.of(Roles.builder().id(UUID.randomUUID().toString()).role(RolesEnum.ROLE_GUEST).build())),
+                new UserDto(UUID.randomUUID().toString(), "admin@aluraflix.com.br", "admin",
+                        Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_ADMIN).build())));
+        when(this.userService.getUsers()).thenReturn(usersList);
+
+        //When
+        final var response = this.userController.getUsers();
+
+        //Then
+        assertThat(response).isNotNull();
+        assertThat(response.getBody()).isNotNull();
+        assertThat(response.getBody()).hasSize(2);
+        assertThat(response.getBody()).usingRecursiveComparison().isEqualTo(usersList);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/controller/VideoControllerTest.java b/src/test/java/com/alura/aluraflixapi/controller/VideoControllerTest.java
index 2c948c2..6bf8f20 100644
--- a/src/test/java/com/alura/aluraflixapi/controller/VideoControllerTest.java
+++ b/src/test/java/com/alura/aluraflixapi/controller/VideoControllerTest.java
@@ -126,20 +126,6 @@ void get_all_videos_test() throws Exception {
         assertEquals(videosExpect.size(), videosDtos.size());
     }
 
-    @Test
-    @DisplayName("Should not return all videos and response No Content")
-    void get_all_videos_response_no_content_test() throws Exception {
-        //Given
-        when(this.videoService.getVideos(Mockito.any()))
-                .thenReturn(Page.empty());
-
-        //Then
-        this.mockMvc.perform(MockMvcRequestBuilders.get("/videos")
-                        .contentType(MediaType.APPLICATION_JSON))
-                .andDo(print())
-                .andExpect(status().is2xxSuccessful());
-    }
-
     @Test
     @DisplayName("Should return a video by Id and response 200 OK")
     void get_video_by_id() throws Exception {
@@ -174,14 +160,8 @@ void get_video_by_id() throws Exception {
     void save_a_new_video_test() throws Exception {
 
         //Given
-        final VideoDto request = VideoDto.builder()
-                .id(UUID.randomUUID().toString())
-                .url("http://www.ringsofpower.com")
-                .title("Rings of power")
-                .description("Rings of power Amazon Series")
-                .category(new CategoryDto(UUID.randomUUID().toString(), Rating.FANTASY.name(), "Fantasy",
-                        "#ffd700"))
-                .build();
+        final VideoDto request = new VideoDto(UUID.randomUUID().toString(), "Rings of power Amazon Series", "Rings of power", "http://www.ringsofpower.com",
+                new CategoryDto(UUID.randomUUID().toString(), Rating.FANTASY.name(), "Fantasy", "#ffd700"));
 
         when(this.videoService.save(Mockito.any()))
                 .thenReturn(request);
@@ -240,17 +220,19 @@ void update_video_by_id_test() throws Exception {
     }
 
     @Test
-    @DisplayName("Should allow delete a video by id and response No Content")
+    @DisplayName("Should allow delete a video by id and response 200 OK")
     void delete_video_by_id_test() throws Exception {
 
         //Given
+        final var videoDto = new VideoDto("63680c011892283477b3e9b9", "63680c011892283477b3e9b9", "best movie ever", "https://lordoftherings.com",
+                new CategoryDto("63f67ec16295ed744dd460cd", "FREE", "Fantasy", "#ffff83"));
         when(this.videoService.delete(Mockito.anyString()))
-                .thenReturn(Optional.empty());
+                .thenReturn(videoDto);
         //then
         this.mockMvc.perform(MockMvcRequestBuilders.delete("/videos/{id}", "1")
                         .with(SecurityMockMvcRequestPostProcessors.csrf().asHeader())
                 ).andDo(print())
-                .andExpect(status().isNoContent());
+                .andExpect(status().is2xxSuccessful());
     }
 
     @Test
diff --git a/src/test/java/com/alura/aluraflixapi/infraestructure/security/TokenServiceTest.java b/src/test/java/com/alura/aluraflixapi/infraestructure/security/TokenServiceTest.java
new file mode 100644
index 0000000..90971da
--- /dev/null
+++ b/src/test/java/com/alura/aluraflixapi/infraestructure/security/TokenServiceTest.java
@@ -0,0 +1,86 @@
+package com.alura.aluraflixapi.infraestructure.security;
+
+import com.alura.aluraflixapi.domain.user.User;
+import com.alura.aluraflixapi.domain.user.roles.Roles;
+import com.alura.aluraflixapi.domain.user.roles.RolesEnum;
+import com.auth0.jwt.exceptions.JWTCreationException;
+import com.auth0.jwt.exceptions.JWTDecodeException;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(SpringExtension.class)
+class TokenServiceTest {
+
+    @SpyBean
+    private TokenService tokenService;
+
+    @Test
+    @DisplayName("Should return a TokenJWT")
+    void generateTokenJWT_test() {
+        //Given
+        final var user = User.builder().id(UUID.randomUUID().toString())
+                .username("admin@aluraflix.com")
+                .password("admin@aluraflix")
+                .roles(Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_ADMIN)
+                        .build()))
+                .build();
+        //When
+        final var tokenJWT = this.tokenService.generateTokenJWT(user);
+        //Then
+        assertThat(tokenJWT)
+                .isNotBlank()
+                .isNotNull();
+    }
+
+    @Test
+    @DisplayName("Should return a JWTCreationException when is generating TokenJWT and some field is null")
+    void generateTokenJWT_KO_test() {
+        //Then
+        Assertions.assertThatExceptionOfType(JWTCreationException.class)
+                .isThrownBy(() -> this.tokenService.generateTokenJWT(null))
+                .withMessageContaining("Error to create JWT token");
+    }
+
+
+    @Test
+    @DisplayName("Should retrieve User Principal from TokenJWT passed")
+    void getSubject_test() {
+        //Given
+        final var user = User.builder().id(UUID.randomUUID().toString())
+                .username("admin@aluraflix.com")
+                .password("admin@aluraflix")
+                .roles(Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_ADMIN)
+                        .build()))
+                .build();
+        final var tokenJWT = this.tokenService.generateTokenJWT(user);
+        //When
+        final var userPrincipal = this.tokenService.getSubject(tokenJWT);
+        //Then
+        assertThat(userPrincipal)
+                .isNotBlank()
+                .isNotNull()
+                .isEqualTo("admin@aluraflix.com");
+    }
+
+    @Test
+    @DisplayName("Should return a JWTDecodeException when is verifying TokenJWT and is null")
+    void getSubject_KO_test() {
+        //Then
+        Assertions.assertThatExceptionOfType(JWTDecodeException.class)
+                .isThrownBy(() -> this.tokenService.getSubject(null))
+                .withMessageContaining("Error verifying JWT Token");
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImplTest.java b/src/test/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImplTest.java
index 6e64ccf..9faa82b 100644
--- a/src/test/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImplTest.java
+++ b/src/test/java/com/alura/aluraflixapi/infraestructure/service/CategoryServiceImplTest.java
@@ -5,179 +5,197 @@
 import com.alura.aluraflixapi.domain.category.dto.CategoryDto;
 import com.alura.aluraflixapi.domain.video.Video;
 import com.alura.aluraflixapi.domain.video.dto.VideoDto;
+import com.alura.aluraflixapi.infraestructure.exception.CategoryServiceException;
 import com.alura.aluraflixapi.infraestructure.mapper.CategoryMapperImpl;
 import com.alura.aluraflixapi.infraestructure.mapper.VideoMapperImpl;
 import com.alura.aluraflixapi.infraestructure.repository.CategoryRepository;
 import com.alura.aluraflixapi.infraestructure.repository.VideoRepository;
-import java.util.List;
-import java.util.Optional;
-import java.util.UUID;
-import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mockito;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.boot.test.mock.mockito.SpyBean;
-import org.springframework.http.HttpStatus;
+import org.springframework.data.mongodb.MongoTransactionException;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
 @ExtendWith(SpringExtension.class)
 class CategoryServiceImplTest {
 
-  @SpyBean
-  private CategoryServiceImpl categoryService;
-
-  @MockBean
-  private CategoryRepository categoryRepository;
-
-  @MockBean
-  private VideoRepository videoRepository;
-
-  @SpyBean
-  private VideoMapperImpl videoMapper;
-
-  @SpyBean
-  private CategoryMapperImpl categoryMapper;
-
-  @Test
-  void should_return_all_categories_in_database() {
-    //Given
-    final var mockCategories = List.of(
-        this.buildCategory(UUID.randomUUID().toString(), Rating.FANTASY.getTitle(),
-            Rating.FANTASY.getHexDecimalColor(),
-            Rating.FANTASY),
-        this.buildCategory(UUID.randomUUID().toString(), Rating.ACTION.getTitle(),
-            Rating.ACTION.getHexDecimalColor(),
-            Rating.ACTION),
-        this.buildCategory(UUID.randomUUID().toString(), Rating.TERROR.getTitle(),
-            Rating.TERROR.getHexDecimalColor(),
-            Rating.TERROR),
-        this.buildCategory(UUID.randomUUID().toString(), Rating.TRILLER.getTitle(),
-            Rating.TRILLER.getHexDecimalColor(),
-            Rating.TRILLER),
-        this.buildCategory(UUID.randomUUID().toString(), Rating.ROMANTIC_COMEDY.getTitle(),
-            Rating.ROMANTIC_COMEDY.getHexDecimalColor(), Rating.ROMANTIC_COMEDY)
-    );
-
-    Mockito.when(this.categoryRepository.findAll()).thenReturn(mockCategories);
-
-    //When
-    final var categoryRetrieved = this.categoryService.categories();
-
-    //Then
-    Assertions.assertThat(mockCategories).usingRecursiveFieldByFieldElementComparator()
-        .isEqualTo(categoryRetrieved);
-  }
-
-  @Test
-  void should_create_a_new_category_test() {
-    //Given
-    String id = UUID.randomUUID().toString();
-    final var newCategoryEntity = this.buildCategory(id,
-        Rating.FANTASY.getTitle(),
-        Rating.FANTASY.getHexDecimalColor(),
-        Rating.FANTASY);
-
-    Mockito.when(this.categoryRepository.save(Mockito.any()))
-        .thenReturn(newCategoryEntity);
-    //When
-    final var categoryDto = this.categoryService.create(this.buildCategoryDto(id,
-        Rating.FANTASY.getTitle(),
-        Rating.FANTASY.getHexDecimalColor(),
-        Rating.FANTASY));
-
-    //When
-    Assertions.assertThat(categoryDto).isNotNull().hasNoNullFieldsOrProperties();
-  }
-
-  @Test
-  void should_findCategory_by_id_test() {
-
-    //Given
-    final var id = UUID.randomUUID().toString();
-    final var catgorySearchedById = this.buildCategory(id,
-        Rating.ACTION.getTitle(),
-        Rating.ACTION.getHexDecimalColor(),
-        Rating.ACTION);
-
-    Mockito.when(this.categoryRepository.findById(Mockito.anyString()))
-        .thenReturn(Optional.of(catgorySearchedById));
-    //When
-    final var categoryFound = this.categoryService.findCategoryById(id);
-
-    //When
-    Assertions.assertThat(categoryFound).isNotNull();
-    Assertions.assertThat(categoryFound.id()).isEqualTo(catgorySearchedById.getId());
-    Assertions.assertThat(categoryFound).hasNoNullFieldsOrProperties();
-
-  }
-
-  @Test
-  void should_delete_a_category_test() {
-
-    //Given
-    final var categoryToBeDeleted = this.buildCategory(UUID.randomUUID().toString(),
-        Rating.ACTION.getTitle(),
-        Rating.ACTION.getHexDecimalColor(),
-        Rating.ACTION);
-
-    //When
-    final var httpstatus = this.categoryService.deleteCategory(categoryToBeDeleted.getId());
-
-    //When
-    Assertions.assertThat(httpstatus)
-        .isNotNull()
-        .isEqualTo(HttpStatus.ACCEPTED);
-  }
-
-  @Test
-  void should_return_a_category_searching_by_video_test() {
-
-    //Given
-    final var categorEntity = this.buildCategory(UUID.randomUUID().toString(),
-        Rating.ACTION.name(), Rating.ACTION.getHexDecimalColor(), Rating.ACTION);
-
-    Mockito.when(this.categoryRepository.findCategoryByRating(Mockito.anyString()))
-        .thenReturn(categorEntity);
-
-    Mockito.when(this.videoRepository.findVideosByCategories(Mockito.anyString()))
-        .thenReturn(List.of(getVideoEntity(UUID.randomUUID().toString(),
-            "Film Lord of the rings", "www.lordoftherings.com",
-            "Lord of the Rings: Fellowship of the ring", categorEntity)));
-
-    //When
-    List<VideoDto> videosByCategory = this.categoryService.getVideosByCategory(
-        Rating.TRILLER.getTitle());
-
-    //When
-    Assertions.assertThat(videosByCategory).isNotNull().isNotEmpty();
-    Assertions.assertThat(videosByCategory.stream().findFirst().get().category()).isNotNull();
-
-  }
-
-  private Category buildCategory(final String id, final String title, String colorHex,
-      final Rating rating) {
-    return Category.builder()
-        .id(id)
-        .title(title)
-        .colorHex(colorHex)
-        .rating(rating.name())
-        .build();
-  }
-
-  private CategoryDto buildCategoryDto(final String id, final String title, String colorHex,
-      final Rating rating) {
-    return new CategoryDto(id, rating.name(), title, colorHex);
-  }
-
-  private Video getVideoEntity(final String id, final String description, final String url,
-      final String title, final Category category) {
-    return Video.builder()
-        .id(id)
-        .description(description)
-        .url(url)
-        .title(title)
-        .category(category)
-        .build();
-  }
+    @SpyBean
+    private CategoryServiceImpl categoryService;
+
+    @MockBean
+    private CategoryRepository categoryRepository;
+
+    @MockBean
+    private VideoRepository videoRepository;
+
+    @SpyBean
+    private VideoMapperImpl videoMapper;
+
+    @SpyBean
+    private CategoryMapperImpl categoryMapper;
+
+    @Test
+    void should_return_all_categories_in_database_test() {
+        //Given
+        final var mockCategories = List.of(
+                this.buildCategory(UUID.randomUUID().toString(), Rating.FANTASY.getTitle(),
+                        Rating.FANTASY.getHexDecimalColor(),
+                        Rating.FANTASY),
+                this.buildCategory(UUID.randomUUID().toString(), Rating.ACTION.getTitle(),
+                        Rating.ACTION.getHexDecimalColor(),
+                        Rating.ACTION),
+                this.buildCategory(UUID.randomUUID().toString(), Rating.TERROR.getTitle(),
+                        Rating.TERROR.getHexDecimalColor(),
+                        Rating.TERROR),
+                this.buildCategory(UUID.randomUUID().toString(), Rating.TRILLER.getTitle(),
+                        Rating.TRILLER.getHexDecimalColor(),
+                        Rating.TRILLER),
+                this.buildCategory(UUID.randomUUID().toString(), Rating.ROMANTIC_COMEDY.getTitle(),
+                        Rating.ROMANTIC_COMEDY.getHexDecimalColor(), Rating.ROMANTIC_COMEDY)
+        );
+
+        when(this.categoryRepository.findAll()).thenReturn(mockCategories);
+
+        //When
+        final var categoryRetrieved = this.categoryService.categories();
+
+        //Then
+        assertThat(categoryRetrieved)
+                .isNotNull()
+                .hasSize(5);
+    }
+
+    @Test
+    void should_create_a_new_category_test() {
+        //Given
+        String id = UUID.randomUUID().toString();
+        final var newCategoryEntity = this.buildCategory(id,
+                Rating.FANTASY.getTitle(),
+                Rating.FANTASY.getHexDecimalColor(),
+                Rating.FANTASY);
+
+        when(this.categoryRepository.save(any()))
+                .thenReturn(newCategoryEntity);
+        //When
+        final var categoryDto = this.categoryService.create(this.buildCategoryDto(id,
+                Rating.FANTASY.getTitle(),
+                Rating.FANTASY.getHexDecimalColor(),
+                Rating.FANTASY));
+
+        //When
+        assertThat(categoryDto)
+                .isNotNull()
+                .hasNoNullFieldsOrProperties();
+    }
+
+    @Test
+    void should_throw_categoryTransactionException_when_create_a_new_category_test() {
+        //Given
+        when(this.categoryRepository.save(any())).thenThrow(MongoTransactionException.class);
+        //When
+        assertThatExceptionOfType(CategoryServiceException.class)
+                .isThrownBy(() -> this.categoryService.create(null)
+                ).withMessageContaining("Error to persist new category");
+    }
+
+    @Test
+    void should_findCategory_by_id_test() {
+
+        //Given
+        final var id = UUID.randomUUID().toString();
+        final var categorySearchedById = this.buildCategory(id,
+                Rating.ACTION.getTitle(),
+                Rating.ACTION.getHexDecimalColor(),
+                Rating.ACTION);
+
+        when(this.categoryRepository.findById(Mockito.anyString()))
+                .thenReturn(Optional.of(categorySearchedById));
+        //When
+        final var categoryFound = this.categoryService.findCategoryById(id);
+
+        //When
+        assertThat(categoryFound).isNotNull();
+        assertThat(categoryFound.id()).isEqualTo(categorySearchedById.getId());
+        assertThat(categoryFound).hasNoNullFieldsOrProperties();
+
+    }
+
+    @Test
+    void should_delete_a_category_test() {
+
+        //Given
+        final var category = this.buildCategory(UUID.randomUUID().toString(),
+                Rating.ACTION.getTitle(),
+                Rating.ACTION.getHexDecimalColor(),
+                Rating.ACTION);
+
+        when(this.categoryRepository.findById(any())).thenReturn(Optional.of(category));
+        //When
+        this.categoryService.deleteCategory(category.getId());
+
+        //Then
+        Mockito.verify(this.categoryService, Mockito.atLeast(1)).deleteCategory(category.getId());
+    }
+
+    @Test
+    void should_return_a_category_searching_by_video_test() {
+
+        //Given
+        final var entity = this.buildCategory(UUID.randomUUID().toString(),
+                Rating.ACTION.name(), Rating.ACTION.getHexDecimalColor(), Rating.ACTION);
+
+        when(this.categoryRepository.findCategoryByRating(Mockito.anyString()))
+                .thenReturn(entity);
+
+        when(this.videoRepository.findVideosByCategories(Mockito.anyString()))
+                .thenReturn(List.of(getVideoEntity(UUID.randomUUID().toString(),
+                        "Film Lord of the rings", "www.lordoftherings.com",
+                        "Lord of the Rings: Fellowship of the ring", entity)));
+
+        //When
+        List<VideoDto> videosByCategory = this.categoryService.getVideosByCategory(
+                Rating.TRILLER.getTitle());
+
+        //When
+        assertThat(videosByCategory).isNotNull().isNotEmpty();
+        assertThat(videosByCategory.stream().findFirst().get().category()).isNotNull();
+
+    }
+
+    private Category buildCategory(final String id, final String title, String colorHex,
+                                   final Rating rating) {
+        return Category.builder()
+                .id(id)
+                .title(title)
+                .colorHex(colorHex)
+                .rating(rating.name())
+                .build();
+    }
+
+    private CategoryDto buildCategoryDto(final String id, final String title, String colorHex,
+                                         final Rating rating) {
+        return new CategoryDto(id, rating.name(), title, colorHex);
+    }
+
+    private Video getVideoEntity(final String id, final String description, final String url,
+                                 final String title, final Category category) {
+        return Video.builder()
+                .id(id)
+                .description(description)
+                .url(url)
+                .title(title)
+                .category(category)
+                .build();
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImplTest.java b/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImplTest.java
new file mode 100644
index 0000000..62b0f6c
--- /dev/null
+++ b/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserDetailsServiceImplTest.java
@@ -0,0 +1,54 @@
+package com.alura.aluraflixapi.infraestructure.service;
+
+import com.alura.aluraflixapi.domain.user.User;
+import com.alura.aluraflixapi.domain.user.roles.Roles;
+import com.alura.aluraflixapi.domain.user.roles.RolesEnum;
+import com.alura.aluraflixapi.infraestructure.repository.UserRepository;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(SpringExtension.class)
+class UserDetailsServiceImplTest {
+
+    @MockBean
+    private UserRepository userRepository;
+
+    @SpyBean
+    private UserDetailsServiceImpl userDetailsService;
+
+    @Test
+    @DisplayName("Should find a user by username and return")
+    void loadUserByUsername_test() {
+        //Given
+        final var user = new User(UUID.randomUUID().toString(), "user@aluraflix.com", "user123456",
+                Set.of(Roles.builder().id(UUID.randomUUID().toString()).role(RolesEnum.ROLE_USER).build()));
+
+        when(this.userRepository.findByUsername(anyString()))
+                .thenReturn(user);
+
+        //When
+        final var userDetails = this.userDetailsService.loadUserByUsername(user.getUsername());
+        //Then
+        assertThat(userDetails).isNotNull();
+        assertThat(userDetails.getUsername()).isEqualTo(user.getUsername());
+        assertThat(userDetails.getPassword()).isEqualTo(user.getPassword());
+        assertThat(userDetails.getAuthorities()).isEqualTo(user.getAuthorities());
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImplTest.java b/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImplTest.java
new file mode 100644
index 0000000..906de45
--- /dev/null
+++ b/src/test/java/com/alura/aluraflixapi/infraestructure/service/UserServiceImplTest.java
@@ -0,0 +1,106 @@
+package com.alura.aluraflixapi.infraestructure.service;
+
+import com.alura.aluraflixapi.domain.user.User;
+import com.alura.aluraflixapi.domain.user.dto.UserDto;
+import com.alura.aluraflixapi.domain.user.roles.Roles;
+import com.alura.aluraflixapi.domain.user.roles.RolesEnum;
+import com.alura.aluraflixapi.infraestructure.mapper.UserMapperImpl;
+import com.alura.aluraflixapi.infraestructure.repository.RoleRepository;
+import com.alura.aluraflixapi.infraestructure.repository.UserRepository;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(SpringExtension.class)
+class UserServiceImplTest {
+
+    @SpyBean
+    private UserServiceImpl userService;
+
+    @MockBean
+    private UserMapperImpl mapper;
+
+    @MockBean
+    private RoleRepository roleRepository;
+
+    @MockBean
+    private UserRepository userRepository;
+
+    @Test
+    @DisplayName("Should save a new user")
+    void saveUser_test() {
+        //Given
+        final var userDto = new UserDto(UUID.randomUUID().toString(),
+                "user@aluraflix.com", new BCryptPasswordEncoder().encode("user@123456"),
+                Set.of(Roles.builder()
+                .id(UUID.randomUUID().toString())
+                .role(RolesEnum.ROLE_USER)
+                .build()));
+        final var user = new User(userDto.id(), userDto.username(), userDto.password(), userDto.roles());
+        when(this.mapper.mapToEntity(any())).thenReturn(user);
+        when(this.roleRepository.saveAll(Mockito.anyList())).thenReturn(userDto.roles().stream().toList());
+        when(this.userRepository.save(any())).thenReturn(user);
+        when(this.mapper.mapToDto(any())).thenReturn(userDto);
+
+        //When
+        final var newUser = this.userService.saveUser(userDto);
+        //Then
+        assertThat(newUser)
+                .isNotNull()
+                .usingRecursiveComparison()
+                .isEqualTo(userDto);
+    }
+
+    @Test
+    @DisplayName("Should retrieve all users")
+    void getUsers_test() {
+        //Given
+        final var usersDto = List.of(new UserDto(UUID.randomUUID().toString(),
+                        "user@aluraflix.com", "user@123456", Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_USER)
+                        .build())),
+                new UserDto(UUID.randomUUID().toString(),
+                        "admin@aluraflix.com", "admin@admin", Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_ADMIN)
+                        .build())),
+                new UserDto(UUID.randomUUID().toString(),
+                        "guest@aluraflix.com", "quest@123456", Set.of(Roles.builder()
+                        .id(UUID.randomUUID().toString())
+                        .role(RolesEnum.ROLE_GUEST)
+                        .build()))
+        );
+        final var users = List.of(
+                new User(usersDto.get(0).id(), usersDto.get(0).username(), usersDto.get(0).password(), usersDto.get(0).roles()),
+                new User(usersDto.get(1).id(), usersDto.get(1).username(), usersDto.get(1).password(), usersDto.get(1).roles()),
+                new User(usersDto.get(2).id(), usersDto.get(2).username(), usersDto.get(2).password(), usersDto.get(2).roles())
+        );
+
+        when(this.userRepository.findAll()).thenReturn(users);
+
+        when(this.mapper.mapToUsersDto(users)).thenReturn(usersDto);
+
+        //When
+        final var response = this.userService.getUsers();
+        //Then
+        assertThat(response)
+                .isNotNull()
+                .hasSize(3)
+                .usingRecursiveComparison()
+                .isEqualTo(usersDto);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImplTest.java b/src/test/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImplTest.java
index eb20800..39f23cf 100644
--- a/src/test/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImplTest.java
+++ b/src/test/java/com/alura/aluraflixapi/infraestructure/service/VideoServiceImplTest.java
@@ -3,11 +3,13 @@
 import com.alura.aluraflixapi.domain.video.Video;
 import com.alura.aluraflixapi.domain.video.dto.UpdateVideoDto;
 import com.alura.aluraflixapi.domain.video.dto.VideoDto;
+import com.alura.aluraflixapi.infraestructure.exception.ResourceNotFoundException;
+import com.alura.aluraflixapi.infraestructure.exception.VideoServiceException;
 import com.alura.aluraflixapi.infraestructure.mapper.VideoMapperImpl;
 import com.alura.aluraflixapi.infraestructure.repository.CategoryRepository;
 import com.alura.aluraflixapi.infraestructure.repository.VideoRepository;
 import com.alura.aluraflixapi.jsonutils.ParseJson;
-import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.boot.test.mock.mockito.MockBean;
@@ -21,7 +23,11 @@
 import java.util.List;
 import java.util.Optional;
 
-import static org.mockito.ArgumentMatchers.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
 @ExtendWith(SpringExtension.class)
@@ -31,14 +37,18 @@ class VideoServiceImplTest extends ParseJson {
 
     @MockBean
     private VideoRepository videoRepository;
+
     @SpyBean
     private VideoMapperImpl videoMapper;
+
     @MockBean
     private CategoryRepository categoryRepository;
+
     @SpyBean
     private VideoServiceImpl videoService;
 
     @Test
+    @DisplayName("Should return all videos")
     void getVideos_response_ok_test() {
         //Given
         final var jsonFile = getJsonFile(PREFIX_PATH + "getAllVideos_response_ok.json");
@@ -53,11 +63,28 @@ void getVideos_response_ok_test() {
         final var response = this.videoService.getVideos(Pageable.ofSize(10));
 
         //Then
-        Assertions.assertThat(response).isNotNull();
-        Assertions.assertThat(response.getContent()).usingRecursiveComparison().isEqualTo(videosDto);
+        assertThat(response).isNotNull();
+        assertThat(response.getContent()).usingRecursiveComparison().isEqualTo(videosDto);
+    }
+
+    @Test
+    @DisplayName("Should return a empty video when getAll is null")
+    void getVideos_response_ko_test() {
+        //Given
+        final var videoWithoutCategory = new Video(null, null, null, null, null);
+        final Page<Video> page = new PageImpl<>(List.of(videoWithoutCategory));
+        when(this.videoRepository.findAll(any(Pageable.class))).thenReturn(page);
+
+        //when
+        final var response = this.videoService.getVideos(Pageable.ofSize(1));
+
+        //Then
+        assertThat(response).isNotNull();
+
     }
 
     @Test
+    @DisplayName("Should save a new video")
     void save_response_ok_test() {
         //Given
         final var jsonFile = getJsonFile(PREFIX_PATH + "create_video_response_ok.json");
@@ -70,11 +97,21 @@ void save_response_ok_test() {
         final var videoCreated = this.videoService.save(videoDto);
 
         //then
-        Assertions.assertThat(videoCreated).isNotNull();
-        Assertions.assertThat(videoCreated).usingRecursiveComparison().isEqualTo(videoDto);
+        assertThat(videoCreated).isNotNull();
+        assertThat(videoCreated).usingRecursiveComparison().isEqualTo(videoDto);
+    }
+
+    @Test
+    @DisplayName("Should throw a VideoServiceException when try to save a new video")
+    void save_response_ko_test() {
+        //When
+        assertThatExceptionOfType(VideoServiceException.class)
+                .isThrownBy(() -> this.videoService.save(null)
+                ).withMessageContaining("Error to persist entity");
     }
 
     @Test
+    @DisplayName("Should receive a VideoUpdateDto and update a video already exist")
     void updateMovie_response_ok_test() {
 
         //Given
@@ -89,11 +126,21 @@ void updateMovie_response_ok_test() {
         final var response = this.videoService.updateMovie(updateVideoDtoParsed);
 
         //Then
-        Assertions.assertThat(response).isNotNull();
-        Assertions.assertThat(response).usingRecursiveComparison().isEqualTo(updateVideoDtoParsed);
+        assertThat(response).isNotNull();
+        assertThat(response).usingRecursiveComparison().isEqualTo(updateVideoDtoParsed);
     }
 
     @Test
+    @DisplayName("Should throw a VideoServiceException when try to update a video")
+    void updateVideo_response_ko_test() {
+        //When
+        assertThatExceptionOfType(VideoServiceException.class)
+                .isThrownBy(() -> this.videoService.updateMovie(null)
+                ).withMessageContaining("Error to update movie");
+    }
+
+    @Test
+    @DisplayName("Should delete a video passing a Id")
     void delete_response_ok_test() {
         //Given
         final var jsonFile = getJsonFile(PREFIX_PATH + "delete_video_response_ok.json");
@@ -106,10 +153,20 @@ void delete_response_ok_test() {
         final var response = this.videoService.delete("63680c011892283477b3e9b9");
 
         //Then
-        Assertions.assertThat(response.get()).usingRecursiveComparison().isEqualTo(videoDto);
+        assertThat(response).usingRecursiveComparison().isEqualTo(videoDto);
+    }
+
+    @Test
+    @DisplayName("Should throw a VideoServiceException when try to update a video")
+    void deleteVideo_response_ko_test() {
+        //When
+        assertThatExceptionOfType(ResourceNotFoundException.class)
+                .isThrownBy(() -> this.videoService.delete(null)
+                ).withMessageContaining("Resource not found:");
     }
 
     @Test
+    @DisplayName("Should return a video filtering by Id")
     void getById_response_ok_test() {
         //Given
         final var jsonFile = getJsonFile(PREFIX_PATH + "getById_video_response_ok.json");
@@ -120,11 +177,22 @@ void getById_response_ok_test() {
         final var response = this.videoService.getById("63680c011892283477b3e9b9");
 
         //Then
-        Assertions.assertThat(response).usingRecursiveComparison().isEqualTo(this.videoMapper.mapToVideoDto(model));
+        assertThat(response).usingRecursiveComparison().isEqualTo(this.videoMapper.mapToVideoDto(model));
     }
 
     @Test
-    void getVideosByTitle_response_ok() {
+    @DisplayName("Should return a ResourceNotFoundException when search by Id")
+    void getById_response_ko_test() {
+        //When
+        assertThatExceptionOfType(ResourceNotFoundException.class)
+                .isThrownBy(() ->  this.videoService.getById(null))
+                .isInstanceOf(ResourceNotFoundException.class)
+                .withMessageContaining("Resource not found for id:");
+    }
+
+    @Test
+    @DisplayName("Should return a List of videos filtering by Video title")
+    void getVideosByTitle_response_ok_test() {
         //Given
         final var jsonFile = getJsonFile(PREFIX_PATH + "getById_video_response_ok.json");
         final var video = parseToJavaObject(jsonFile, Video.class);
@@ -135,6 +203,16 @@ void getVideosByTitle_response_ok() {
         final var response = this.videoService.getVideosByTitle("Fantasy");
 
         //Then
-        Assertions.assertThat(response.get(0)).usingRecursiveComparison().isEqualTo(videoDtoExpected);
+        assertThat(response.get(0)).usingRecursiveComparison().isEqualTo(videoDtoExpected);
+    }
+
+    @Test
+    @DisplayName("Should return a ResourceNotFoundException when search by Id")
+    void getVideosByTitle_response_ko_test() {
+        //When
+        assertThatExceptionOfType(ResourceNotFoundException.class)
+                .isThrownBy(() ->  this.videoService.getVideosByTitle(null))
+                .isInstanceOf(ResourceNotFoundException.class)
+                .withMessageContaining("Video not found with title:");
     }
 }
\ No newline at end of file
diff --git a/src/test/resources/json/video/delete_video_response_ok.json b/src/test/resources/json/video/delete_video_response_ok.json
index c23afe5..1d9b2ea 100644
--- a/src/test/resources/json/video/delete_video_response_ok.json
+++ b/src/test/resources/json/video/delete_video_response_ok.json
@@ -1,6 +1,6 @@
 {
   "id": "63680c011892283477b3e9b9",
-  "title": "Lord of the rings - The fellowship of the ring",
+  "title": "63680c011892283477b3e9b9",
   "description": "best movie ever",
   "url": "https://lordoftherings.com",
   "category": {