public async Task ReturnBadRequest_WhenInvalidFilterIsProvided()
{
var rawFilter = new RawFilter
{
MinRating = 2,
MaxRating = 1
};
var expectedError = new Error
{
Type = ErrorType.MinRatingGreaterThanMax.ToString(),
Message = ErrorMessage.Create(ErrorType.MinRatingGreaterThanMax)
};
_mockQueryHandler
.Setup(handler => handler.GetLatestFeedBack(It.IsAny <RawFilter>()))
.ReturnsAsync(Result.Fail <IReadOnlyCollection <PlayerFeedbackDto> >(expectedError));
var controller =
new PlayerFeedbackController(_mockQueryHandler.Object, _mockFeedbackSender.Object, _mockClock.Object);
var responseResult = await controller.Get(rawFilter);
var response = Assert.IsType <BadRequestObjectResult>(responseResult.Result);
var receivedError = Assert.IsAssignableFrom <Error>(response.Value);
Assert.Equal(StatusCodes.Status400BadRequest, response.StatusCode);
Assert.Equal(expectedError, receivedError);
}
public async Task ReturnOkWithFeedbacks_WhenValidFilterIsProvided()
{
var rawFilter = new RawFilter
{
MinRating = 2,
MaxRating = 3
};
var feedbacks = Array.AsReadOnly(new[] { _defaultPlayerFeedbackDto });
_mockQueryHandler
.Setup(handler => handler.GetLatestFeedBack(It.IsAny <RawFilter>()))
.ReturnsAsync(Result.Ok <IReadOnlyCollection <PlayerFeedbackDto> >(new[] { _defaultPlayerFeedbackDto }));
var controller =
new PlayerFeedbackController(_mockQueryHandler.Object, _mockFeedbackSender.Object, _mockClock.Object);
var responseResult = await controller.Get(rawFilter);
var expectedPlayerFeedback = new PlayerFeedbackResponse
{
SessionId = _defaultPlayerFeedbackDto.SessionId,
PlayerId = _defaultPlayerFeedbackDto.PlayerId,
Rating = _defaultPlayerFeedbackDto.Rating,
Comment = _defaultPlayerFeedbackDto.Comment,
Timestamp = _defaultPlayerFeedbackDto.Timestamp
};
var response = Assert.IsType <OkObjectResult>(responseResult.Result);
var receivedFeedbacks = Assert.IsAssignableFrom <IEnumerable <PlayerFeedbackResponse> >(response.Value);
Assert.Equal(StatusCodes.Status200OK, response.StatusCode);
Assert.Equal(expectedPlayerFeedback, receivedFeedbacks.First());
}
public void ShouldReturnOkAndDefaultFilter_WhenRawFilterIsEmpty()
{
var rawFilter = new RawFilter
{
MinRating = null,
MaxRating = null
};
var filterCreationResult = QueryFilter.CreateFrom(rawFilter);
Assert.True(filterCreationResult.IsOk);
Assert.Equal(_defaultFilter, filterCreationResult.Value);
}
public async Task ReturnError_WhenInvalidFilterIsGiven()
{
var rawFilter = new RawFilter
{
MinRating = -1,
MaxRating = null
};
var queryHandler = new QueryHandler(_mockFeedbackRepository.Object);
var result = await queryHandler.GetLatestFeedBack(rawFilter);
Assert.True(result.IsError);
}
public void ShouldReturnError_WhenMinRatingIsGreaterThanMax()
{
var rawFilter = new RawFilter
{
MinRating = 4,
MaxRating = 1
};
var filterCreationResult = QueryFilter.CreateFrom(rawFilter);
var expectedError = new Error
{
Type = ErrorType.MinRatingGreaterThanMax.ToString(),
Message = ErrorMessage.MinRatingGreaterThanMax
};
Assert.True(filterCreationResult.IsError);
Assert.Equal(expectedError, filterCreationResult.Error);
}
public void ShouldReturnError_WhenMinMaxRatingIsOutOfRange(int?min, int?max)
{
var rawFilter = new RawFilter
{
MinRating = min,
MaxRating = max
};
var filterCreationResult = QueryFilter.CreateFrom(rawFilter);
var expectedError = new Error
{
Type = ErrorType.RatingOutOfRange.ToString(),
Message = ErrorMessage.RatingOutOfRangeMessage
};
Assert.True(filterCreationResult.IsError);
Assert.Equal(expectedError, filterCreationResult.Error);
}
public void saveFilter(Filter filter)
{
RawFilter raw;
try
{
if (filter.Id == 0)
{
filter.Id = getFiltersNextId();
}
raw = new RawFilter(filter);
command = "INSERT OR REPLACE INTO filters(\n";
command += "id,\n";
command += "isBase,\n";
command += "description,\n";
command += "value)\n";
command += "values (\n";
command += "@id,\n";
command += "@isBase,\n";
command += "@description,\n";
command += "@value)\n";
parameters = new List <clsDataBaseParametes>();
parameters.Add(new clsDataBaseParametes("@id", raw.id.ToString()));
parameters.Add(new clsDataBaseParametes("@isBase", raw.isBase.ToString()));
parameters.Add(new clsDataBaseParametes("@description", raw.description));
parameters.Add(new clsDataBaseParametes("@value", raw.value));
dataBase.sbExecute(command, parameters);
dataBase.sbCommit();
}
catch (DataBaseException exdb)
{
throw new Exception("Database error: " + exdb.Code + " - " + exdb.Message);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task ReturnPlayerFeedbacks_WhenValidFilterIsGiven()
{
var rawFilter = new RawFilter
{
MinRating = 3,
MaxRating = 3
};
_mockFeedbackRepository
.Setup(repo => repo.GetLatestBy(It.IsAny <QueryFilter>()))
.ReturnsAsync(new [] { _playerFeedback });
var queryHandler = new QueryHandler(_mockFeedbackRepository.Object);
var result = await queryHandler.GetLatestFeedBack(rawFilter);
var expectedResult = new[] { _playerFeedback }.AsEnumerable();
Assert.True(result.IsOk);
Assert.Equal(expectedResult, result.Value);
}
public void ShouldReturnFilter_WhenValidRatingRangeIsGiven(int?min, int?max)
{
var rawFilter = new RawFilter
{
MinRating = min,
MaxRating = max
};
var filterCreationResult = QueryFilter.CreateFrom(rawFilter);
var expectedFilter = new QueryFilter
{
RatingRange = new RatingRange
{
Min = min.Value,
Max = max.Value
}
};
Assert.True(filterCreationResult.IsOk);
Assert.Equal(expectedFilter, filterCreationResult.Value);
}
public async Task <ActionResult <IEnumerable <PlayerFeedbackResponse> > > Get([FromQuery] RawFilter filter = null)
{
var queryResult = await _queryHandler.GetLatestFeedBack(filter);
if (queryResult.IsOk)
{
var response = queryResult.Value.Select(PlayerFeedbackResponse.CreateFromDto);
return(Ok(response));
}
return(BadRequest(queryResult.Error));
}
public async Task<Result<IReadOnlyCollection<PlayerFeedbackDto>>> GetLatestFeedBack(RawFilter filter)
{
var filterValidation = QueryFilter.CreateFrom(filter);
if (filterValidation.IsOk)
{
var feedbacks = await _playerFeedback.GetLatestBy(filterValidation.Value);
return Result.Ok(feedbacks);
}
return Result.Fail<IReadOnlyCollection<PlayerFeedbackDto>>(filterValidation.Error);
}
