Feature/delete favorites

src/Tests/HttpDebug/debug-tests.http

@@ -23,4 +23,8 @@ Content-Type: application/json
  "latitude": 38.5,
  "longitude": -78.5
  }
-}
+}
+
+### add favorites weather request
+DELETE https://{{host}}/weather/v1/favorite/1
+Content-Type: application/json

src/Tests/Weather.API.UnitTests/Features/AddFavorites/AddFavoriteHandlerTests.cs

@@ -22,14 +22,14 @@ public class AddFavoriteHandlerTests
  private readonly Mock<IMapper> _mapperMock;
  private readonly Mock<DbSet<FavoriteLocationEntity>> _favoriteLocationEntityDbSetMock;
 
- private readonly IRequestHandler<bool, AddFavoriteCommand> _uut;
+ private readonly IRequestHandler<int, AddFavoriteCommand> _uut;
  public AddFavoriteHandlerTests()
  {
  _favoriteLocationEntityDbSetMock = new();
  _weatherContextMock = new();
  _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
 
- _addFavoriteCommandValidatorMock = new Mock<IValidator<AddFavoriteCommand>>();
+ _addFavoriteCommandValidatorMock = new();
  _loggerMock = new();
  _mapperMock = new();
 
@@ -51,7 +51,6 @@ public async Task InvalidLocation()
  //Assert
  Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
  Assert.Single(result.Errors);
- Assert.False(result.Data);
  _addFavoriteCommandValidatorMock.Verify(x => x.IsValid(It.Is<AddFavoriteCommand>(y => y.Equals(addFavoriteCommand))), Times.Once);
  }
 
@@ -72,7 +71,6 @@ public async Task AddFavoriteLocation_Failed()
  //Assert
  Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode);
  Assert.Single(result.Errors);
- Assert.False(result.Data);
  _addFavoriteCommandValidatorMock.Verify(x => x.IsValid(It.Is<AddFavoriteCommand>(y => y.Equals(addFavoriteCommand))), Times.Once);
  _loggerMock.VerifyLog(LogLevel.Error, LogEvents.FavoriteWeathersStoreToDatabase, Times.Once());
  }
@@ -96,7 +94,6 @@ public async Task Success()
  //Assert
  Assert.Equal(HttpStatusCode.OK, result.StatusCode);
  Assert.Empty(result.Errors);
- Assert.True(result.Data);
  _addFavoriteCommandValidatorMock.Verify(x => x.IsValid(It.Is<AddFavoriteCommand>(y => y.Equals(addFavoriteCommand))), Times.Once);
  _favoriteLocationEntityDbSetMock.Verify(x => x.AddAsync(It.IsAny<FavoriteLocationEntity>(), It.IsAny<CancellationToken>()), Times.Once);
  }

src/Tests/Weather.API.UnitTests/Features/DeleteFavorites/DeleteFavoriteHandlerTests.cs

@@ -0,0 +1,91 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Moq;
+using System.Net;
+using Validot;
+using Weather.API.Domain.Abstractions;
+using Weather.API.Domain.Database.Entities;
+using Weather.API.Features.DeleteFavorites;
+using Weather.API.UnitTests.Domain.Database;
+
+
+namespace Weather.API.UnitTests.Features.DeleteFavorites
+{
+ public class DeleteFavoriteHandlerTests
+ {
+ private readonly Mock<IValidator<DeleteFavoriteCommand>> _deleteFavoriteCommandValidatorMock;
+ private readonly Mock<TestWeatherContext> _weatherContextMock;
+ private readonly Mock<DbSet<FavoriteLocationEntity>> _favoriteLocationEntityDbSetMock;
+
+ private readonly IRequestHandler<bool, DeleteFavoriteCommand> _uut;
+ public DeleteFavoriteHandlerTests()
+ {
+ _deleteFavoriteCommandValidatorMock = new();
+ var loggerMock = new Mock<ILogger<DeleteFavoriteHandler>>();
+ _weatherContextMock = new();
+ _favoriteLocationEntityDbSetMock = new();
+
+ _uut = new DeleteFavoriteHandler(_deleteFavoriteCommandValidatorMock.Object, loggerMock.Object, _weatherContextMock.Object);
+ }
+
+ [Fact]
+ public async Task InvalidRequest()
+ {
+ //Arrange
+ var deleteFavoriteCommand = new DeleteFavoriteCommand { Id = 1 };
+
+ _deleteFavoriteCommandValidatorMock.Setup(x => x.IsValid(deleteFavoriteCommand)).Returns(false);
+
+ //Act
+ var result = await _uut.HandleAsync(deleteFavoriteCommand, CancellationToken.None);
+
+ //Assert
+ Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
+ Assert.Single(result.Errors);
+ Assert.False(result.Data);
+ }
+
+ [Fact]
+ public async Task DeleteFavoriteLocationSafeAsync_Failed()
+ {
+ //Arrange
+ var deleteFavoriteCommand = new DeleteFavoriteCommand { Id = 1 };
+
+ _deleteFavoriteCommandValidatorMock.Setup(x => x.IsValid(deleteFavoriteCommand)).Returns(true);
+
+ _favoriteLocationEntityDbSetMock.Setup(x => x.FindAsync(It.IsAny<int>(), CancellationToken.None)).ThrowsAsync(new DbUpdateException());
+ _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
+
+ //Act
+ var result = await _uut.HandleAsync(deleteFavoriteCommand, CancellationToken.None);
+
+ //Assert
+ Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode);
+ Assert.Single(result.Errors);
+ Assert.False(result.Data);
+ }
+
+ [Fact]
+ public async Task Success()
+ {
+ //Arrange
+ var deleteFavoriteCommand = new DeleteFavoriteCommand { Id = 1 };
+
+ _deleteFavoriteCommandValidatorMock.Setup(x => x.IsValid(deleteFavoriteCommand)).Returns(true);
+
+ var favoriteLocation = new FavoriteLocationEntity();
+ _favoriteLocationEntityDbSetMock.Setup(x => x.FindAsync(It.IsAny<int>(), CancellationToken.None)).ReturnsAsync(favoriteLocation);
+ _favoriteLocationEntityDbSetMock.Setup(x => x.Remove(favoriteLocation));
+ _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
+
+ //Act
+ var result = await _uut.HandleAsync(deleteFavoriteCommand, CancellationToken.None);
+
+ //Assert
+ Assert.Equal(HttpStatusCode.OK, result.StatusCode);
+ Assert.Empty(result.Errors);
+ Assert.True(result.Data);
+ }
+
+ }
+}

src/Tests/Weather.API.UnitTests/Features/GetFavorites/GetFavoritesHandlerTests.cs

@@ -35,7 +35,6 @@ public GetFavoritesHandlerTests()
  _currentWeatherValidatorMock = new();
  _weatherContextMock = new();
  _mapperMock = new();
-
  _favoriteLocationEntityDbSetMock = new();
 
  _uut = new GetFavoritesHandler(
@@ -94,11 +93,10 @@ public async Task EmptyResult_GetCurrentWeather_Fail()
  var favoriteLocations = new List<FavoriteLocationEntity>() { new() };
  _favoriteLocationEntityDbSetMock.SetupMock(favoriteLocations);
  _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
- _mapperMock.Setup(x => x.Map<List<LocationDto>>(favoriteLocations)).Returns(new List<LocationDto> { locationDto });
-
+ _mapperMock.Setup(x => x.Map<LocationDto>(It.IsAny<FavoriteLocationEntity>())).Returns(locationDto);
  _locationValidatorMock.Setup(x => x.IsValid(It.IsAny<LocationDto>())).Returns(true);
-
  _weatherServiceMock.Setup(x => x.GetCurrentWeather(It.IsAny<LocationDto>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Fail(failMessage));
+
  //Act
  var result = await _uut.HandleAsync(EmptyRequest.Instance, CancellationToken.None);
 
@@ -117,11 +115,11 @@ public async Task One_Of_GetCurrentWeather_Failed()
  var failMessage = "Some fail message";
  var locationDto = new LocationDto { Latitude = 1, Longitude = 1 };
 
- var favoriteLocations = new List<FavoriteLocationEntity>() { new() };
+ var favoriteLocations = new List<FavoriteLocationEntity> { new(), new FavoriteLocationEntity { Latitude = locationDto.Latitude, Longitude = locationDto.Longitude } };
  _favoriteLocationEntityDbSetMock.SetupMock(favoriteLocations);
  _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
- _mapperMock.Setup(x => x.Map<List<LocationDto>>(favoriteLocations)).Returns(new List<LocationDto> { locationDto, new() });
-
+ _mapperMock.Setup(x => x.Map<LocationDto>(It.Is<FavoriteLocationEntity>(y=> y.Latitude!= locationDto.Latitude))).Returns(new LocationDto());
+ _mapperMock.Setup(x => x.Map<LocationDto>(It.Is<FavoriteLocationEntity>(y => y.Latitude == locationDto.Latitude))).Returns(locationDto);
  _locationValidatorMock.Setup(x => x.IsValid(It.IsAny<LocationDto>())).Returns(true);
 
  var currentWeather = new CurrentWeatherDto();
@@ -138,7 +136,6 @@ public async Task One_Of_GetCurrentWeather_Failed()
  Assert.Single(result.Errors);
  Assert.NotNull(result.Data);
  Assert.Single(result.Data.FavoriteWeathers);
- Assert.Equal(currentWeather, result.Data.FavoriteWeathers.Single());
  _weatherServiceMock.Verify(x => x.GetCurrentWeather(It.IsAny<LocationDto>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
  _loggerMock.VerifyLog(LogLevel.Warning, LogEvents.FavoriteWeathersGeneral, failMessage, Times.Once());
  _locationValidatorMock.Verify(x => x.IsValid(It.Is<LocationDto>(y => y.Equals(locationDto))), Times.Once);
@@ -154,7 +151,7 @@ public async Task GetCurrentWeather_Validation_Fail()
  var favoriteLocations = new List<FavoriteLocationEntity>() { new() };
  _favoriteLocationEntityDbSetMock.SetupMock(favoriteLocations);
  _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
- _mapperMock.Setup(x => x.Map<List<LocationDto>>(favoriteLocations)).Returns(new List<LocationDto> { locationDto });
+ _mapperMock.Setup(x => x.Map<LocationDto>(It.IsAny<FavoriteLocationEntity>())).Returns(locationDto);
 
  _locationValidatorMock.Setup(x => x.IsValid(It.IsAny<LocationDto>())).Returns(true);
  _currentWeatherValidatorMock.Setup(x => x.IsValid(It.IsAny<CurrentWeatherDto>())).Returns(false);
@@ -182,7 +179,7 @@ public async Task Success()
  var favoriteLocations = new List<FavoriteLocationEntity>() { new() };
  _favoriteLocationEntityDbSetMock.SetupMock(favoriteLocations);
  _weatherContextMock.Setup(x => x.FavoriteLocations).Returns(_favoriteLocationEntityDbSetMock.Object);
- _mapperMock.Setup(x => x.Map<List<LocationDto>>(favoriteLocations)).Returns(new List<LocationDto> { locationDto });
+ _mapperMock.Setup(x => x.Map<LocationDto>(It.IsAny<FavoriteLocationEntity>())).Returns(locationDto);
 
  _locationValidatorMock.Setup(x => x.IsValid(It.IsAny<LocationDto>())).Returns(true);
  _currentWeatherValidatorMock.Setup(x => x.IsValid(It.IsAny<CurrentWeatherDto>())).Returns(true);
@@ -197,7 +194,6 @@ public async Task Success()
  Assert.Empty(result.Errors);
  Assert.NotNull(result.Data);
  Assert.Single(result.Data.FavoriteWeathers);
- Assert.Equal(currentWeather, result.Data.FavoriteWeathers.Single());
  _weatherServiceMock.Verify(x => x.GetCurrentWeather(It.Is<LocationDto>(y => y.Equals(locationDto)), It.IsAny<CancellationToken>()), Times.Once);
  _locationValidatorMock.Verify(x => x.IsValid(It.Is<LocationDto>(y => y.Equals(locationDto))), Times.Once);
  _currentWeatherValidatorMock.Verify(x => x.IsValid(It.Is<CurrentWeatherDto>(y => y.Equals(currentWeather))), Times.Once);

src/Weather.API/Domain/Dtos/CurrentWeatherDto.cs

@@ -1,6 +1,6 @@
 namespace Weather.API.Domain.Dtos
 {
- public sealed class CurrentWeatherDto
+ public class CurrentWeatherDto
  {
  public double Temperature { get; init; }
 

src/Weather.API/Features/AddFavorites/AddFavoriteHandler.cs

@@ -13,7 +13,7 @@
 
 namespace Weather.API.Features.Favorites.AddFavorites
 {
- internal sealed class AddFavoriteHandler : IRequestHandler<bool, AddFavoriteCommand>
+ internal sealed class AddFavoriteHandler : IRequestHandler<int, AddFavoriteCommand>
  {
  private readonly IMapper _mapper;
  private readonly WeatherContext _weatherContext;
@@ -31,20 +31,20 @@ public AddFavoriteHandler(
  _mapper = Guard.Against.Null(mapper);
  }
 
- public async Task<HttpDataResponse<bool>> HandleAsync(AddFavoriteCommand request, CancellationToken cancellationToken)
+ public async Task<HttpDataResponse<int>> HandleAsync(AddFavoriteCommand request, CancellationToken cancellationToken)
  {
  if (!_addFavoriteCommandValidator.IsValid(request))
  {
- return HttpDataResponses.AsBadRequest<bool>(string.Format(ErrorMessages.RequestValidationError, request));
+ return HttpDataResponses.AsBadRequest<int>(string.Format(ErrorMessages.RequestValidationError, request));
  }
 
  var addResult = await AddFavoriteLocationSafeAsync(request, cancellationToken);
  if (addResult.IsFailed)
  {
- return HttpDataResponses.AsInternalServerError<bool>("Location was not stored in database.");
+ return HttpDataResponses.AsInternalServerError<int>("Location was not stored in database.");
  }
 
- return HttpDataResponses.AsOK(true);
+ return HttpDataResponses.AsOK(addResult.Value);
  }
 
  public async Task<Result<int>> AddFavoriteLocationSafeAsync(AddFavoriteCommand addFavoriteCommand, CancellationToken cancellationToken)

src/Weather.API/Features/AddFavorites/ContainerConfigurationExtension.cs

@@ -12,9 +12,9 @@ public static class ContainerConfigurationExtension
  public static IEndpointRouteBuilder BuildAddFavoriteWeatherEndpoints(this IEndpointRouteBuilder endpointRouteBuilder)
  {
  endpointRouteBuilder.MapPost("v1/favorite",
- async ([FromBody] AddFavoriteCommand addFavoriteCommand, [FromServices] IRequestHandler<bool, AddFavoriteCommand> handler, CancellationToken cancellationToken) =>
+ async ([FromBody] AddFavoriteCommand addFavoriteCommand, [FromServices] IRequestHandler<int, AddFavoriteCommand> handler, CancellationToken cancellationToken) =>
  await handler.SendAsync(addFavoriteCommand, cancellationToken))
- .Produces<DataResponse<bool>>()
+ .Produces<DataResponse<int>>()
  .WithName("AddFavorite")
  .WithTags("Setters");
 
@@ -23,7 +23,7 @@ await handler.SendAsync(addFavoriteCommand, cancellationToken))
 
  public static IServiceCollection AddAddFavorites(this IServiceCollection serviceCollection) 
  => serviceCollection
- .AddScoped<IRequestHandler<bool, AddFavoriteCommand>, AddFavoriteHandler>()
+ .AddScoped<IRequestHandler<int, AddFavoriteCommand>, AddFavoriteHandler>()
  .AddValidotSingleton<IValidator<AddFavoriteCommand>, AddFavoriteCommandSpecificationHolder, AddFavoriteCommand>();
 
  }

src/Weather.API/Features/DeleteFavorites/ContainerConfigurationExtension.cs

@@ -0,0 +1,29 @@
+using Microsoft.AspNetCore.Mvc;
+using Validot;
+using Weather.API.Domain.Abstractions;
+using Weather.API.Domain.Extensions;
+using WeatherApi.Domain.Http;
+
+namespace Weather.API.Features.DeleteFavorites
+{
+ public static class ContainerConfigurationExtension
+ {
+ public static IEndpointRouteBuilder BuildDeleteFavoriteWeatherEndpoints(this IEndpointRouteBuilder endpointRouteBuilder)
+ {
+ endpointRouteBuilder.MapDelete("v1/favorite/{id}",
+ async (int id, [FromServices] IRequestHandler<bool, DeleteFavoriteCommand> handler, CancellationToken cancellationToken) =>
+ await handler.SendAsync(new DeleteFavoriteCommand { Id = id }, cancellationToken))
+ .Produces<DataResponse<bool>>()
+ .WithName("DeleteFavorite")
+ .WithTags("Delete");
+
+ return endpointRouteBuilder;
+ }
+
+ public static IServiceCollection AddDeleteFavorites(this IServiceCollection serviceCollection)
+ => serviceCollection
+ .AddScoped<IRequestHandler<bool, DeleteFavoriteCommand>, DeleteFavoriteHandler>()
+ .AddValidotSingleton<IValidator<DeleteFavoriteCommand>, DeleteFavoriteCommandSpecificationHolder, DeleteFavoriteCommand>();
+
+ }
+}

src/Weather.API/Features/DeleteFavorites/DeleteFavoriteCommand.cs

@@ -0,0 +1,7 @@
+namespace Weather.API.Features.DeleteFavorites
+{
+ internal sealed class DeleteFavoriteCommand
+ {
+ public int Id { get; init; }
+ }
+}

src/Weather.API/Features/DeleteFavorites/DeleteFavoriteCommandSpecificationHolder.cs

@@ -0,0 +1,17 @@
+using Validot;
+
+namespace Weather.API.Features.DeleteFavorites
+{
+ internal sealed class DeleteFavoriteCommandSpecificationHolder : ISpecificationHolder<DeleteFavoriteCommand>
+ {
+ public Specification<DeleteFavoriteCommand> Specification { get; }
+
+ public DeleteFavoriteCommandSpecificationHolder()
+ {
+ Specification<DeleteFavoriteCommand> addFavoriteCommandSpecification = s => s
+ .Member(m => m.Id, r => r.NonNegative());
+
+ Specification = addFavoriteCommandSpecification;
+ }
+ }
+}

src/Weather.API/Features/DeleteFavorites/DeleteFavoriteHandler.cs

@@ -0,0 +1,61 @@
+using Ardalis.GuardClauses;
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using Validot;
+using Weather.API.Domain.Abstractions;
+using Weather.API.Domain.Database.EFContext;
+using Weather.API.Domain.Extensions;
+using Weather.API.Domain.Logging;
+using Weather.API.Domain.Resources;
+using WeatherApi.Domain.Http;
+
+namespace Weather.API.Features.DeleteFavorites
+{
+ internal sealed class DeleteFavoriteHandler : IRequestHandler<bool, DeleteFavoriteCommand>
+ {
+ private readonly WeatherContext _weatherContext;
+ private readonly IValidator<DeleteFavoriteCommand> _validator;
+ private readonly ILogger<DeleteFavoriteHandler> _logger;
+ public DeleteFavoriteHandler(
+ IValidator<DeleteFavoriteCommand> validator,
+ ILogger<DeleteFavoriteHandler> logger,
+ WeatherContext weatherContext)
+ {
+ _validator = Guard.Against.Null(validator);
+ _logger = Guard.Against.Null(logger);
+ _weatherContext = Guard.Against.Null(weatherContext);
+ }
+
+ public async Task<HttpDataResponse<bool>> HandleAsync(DeleteFavoriteCommand request, CancellationToken cancellationToken)
+ {
+ if (!_validator.IsValid(request))
+ {
+ return HttpDataResponses.AsBadRequest<bool>(string.Format(ErrorMessages.RequestValidationError, request));
+ }
+
+ var addResult = await DeleteFavoriteLocationSafeAsync(request, cancellationToken);
+ if (addResult.IsFailed)
+ {
+ return HttpDataResponses.AsInternalServerError<bool>("Location was not deleted from database.");
+ }
+
+ return HttpDataResponses.AsOK(true);
+ }
+
+ public async Task<Result> DeleteFavoriteLocationSafeAsync(DeleteFavoriteCommand command, CancellationToken cancellationToken)
+ {
+ try
+ {
+ var location = await _weatherContext.FavoriteLocations.FindAsync(command.Id, cancellationToken);
+ _weatherContext.Remove(location!);
+ await _weatherContext.SaveChangesAsync(cancellationToken);
+ return Result.Ok();
+ }
+ catch (DbUpdateException ex)
+ {
+ _logger.LogError(LogEvents.FavoriteWeathersStoreToDatabase, ex, "Can't delete location.");
+ return Result.Fail(ex.Message);
+ }
+ }
+ }
+}