@Test
    public void createBeer_Should_Return_CreatedBeer_When_ValidBeerDto() throws Exception {
        // Arrange
        BeerDto beerDto = createMockBeerDto();
        Beer mockBeer = createMockBeer();

        Mockito.when(beerMapper.fromDto(Mockito.any(BeerDto.class))).thenReturn(createMockBeerFromBeerDto());
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any())).thenReturn(createMockUserAdmin());
        Mockito.when(beerService.create(Mockito.any(Beer.class), Mockito.any(User.class))).thenReturn(mockBeer);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.post("/api/beers")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isCreated())
                .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("MockBeerName"))
                .andExpect(MockMvcResultMatchers.jsonPath("$.style.name").value("MockStyleName"))  // Corrected path to style name
                .andExpect(MockMvcResultMatchers.jsonPath("$.abv").value(5.5));
    }

    @Test
    public void createBeer_ShouldReturn_NotFound_When_StyleId_IsInvalid() throws Exception {
        // Arrange
        Mockito.when(beerMapper.fromDto(Mockito.any(BeerDto.class))).thenThrow(EntityNotFoundException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.post("/api/beers")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isNotFound());
    }

    @Test
    public void createBeer_ShouldReturn_CONFLICT_When_DuplicateName() throws Exception {
        // Arrange
        Mockito.when(beerService.create(Mockito.any(), Mockito.any()))
                .thenThrow(DuplicateEntityException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.post("/api/beers")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isConflict());
    }

    @Test
    public void createBeer_ShouldReturn_Unauthorized_When_UnauthorizedExcThrown() throws Exception {
        // Arrange
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any()))
                .thenThrow(UnauthorizedAccessException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.post("/api/beers")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isUnauthorized());
    }


    // UPDATE


    @Test
    public void updateBeer_ShouldReturn_UpdatedBeer_When_ValidRequest() throws Exception {
        // Arrange
        Beer mockBeer = createMockBeerFromBeerDtoWithId();

        Mockito.when(beerMapper.fromDto(Mockito.anyInt(), Mockito.any(BeerDto.class))).thenReturn(mockBeer);
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any())).thenReturn(createMockUserAdmin());
        Mockito.when(beerService.update(Mockito.any(Beer.class), Mockito.any(User.class))).thenReturn(mockBeer);

        // Act & Assert
        mockMvc.perform(MockMvcRequestBuilders.put("/api/beers/{id}", 1)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("MockBeerName"))
                .andExpect(MockMvcResultMatchers.jsonPath("$.style.name").value("MockStyleName"))
                .andExpect(MockMvcResultMatchers.jsonPath("$.abv").value(5.5));
    }

    @Test
    public void updateBeer_ShouldReturn_NotFound_When_StyleId_IsInvalid() throws Exception {
        // Arrange
        Mockito.when(beerMapper.fromDto(Mockito.anyInt(), Mockito.any(BeerDto.class)))
                .thenThrow(EntityNotFoundException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.put("/api/beers/{id}", 1)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isNotFound());
    }

    @Test
    public void updateBeer_ShouldReturn_CONFLICT_When_DuplicateName() throws Exception {
        // Arrange
        Mockito.when(beerService.update(Mockito.any(), Mockito.any()))
                .thenThrow(DuplicateEntityException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.put("/api/beers/{id}", 1)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isConflict());
    }

    @Test
    public void updateBeer_ShouldReturn_Unauthorized_When_UnauthorizedExcThrown() throws Exception {
        // Arrange
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any()))
                .thenThrow(UnauthorizedAccessException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.put("/api/beers/{id}", 1)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{\"name\": \"MockBeerName\", \"abv\": 5.5, \"styleId\": 1}")
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isUnauthorized());
    }

    // DELETE

    @Test
    public void deleteBeer_ShouldReturn_StatusOK_When_ValidRequest() throws Exception {
        // Arrange
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any())).thenReturn(createMockUserAdmin());
        Mockito.when(beerService.delete(Mockito.anyInt(), Mockito.any(User.class))).thenReturn(createMockBeer());

        // Act & Assert
        mockMvc.perform(MockMvcRequestBuilders.delete("/api/beers/{id}", 1)
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isOk());
    }

    @Test
    public void deleteBeer_ShouldReturn_NotFound_When_BeerId_IsInvalid() throws Exception {
        // Arrange
        Mockito.when(beerService.delete(Mockito.anyInt(), Mockito.any()))
                .thenThrow(EntityNotFoundException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.delete("/api/beers/{id}", 1)
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isNotFound());
    }


    @Test
    public void deleteBeer_ShouldReturn_Unauthorized_When_UnauthorizedExcThrown() throws Exception {
        // Arrange
        Mockito.when(authenticationHelper.tryGetUser(Mockito.any()))
                .thenThrow(UnauthorizedAccessException.class);

        // Act, Assert
        mockMvc.perform(MockMvcRequestBuilders.delete("/api/beers/{id}", 1)
                        .header(HttpHeaders.AUTHORIZATION, "valid"))
                .andExpect(MockMvcResultMatchers.status().isUnauthorized());
    }