public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
{
try
{
if (ModelState.IsValid)
{
ForecastRequestDto requestDto = _requestMapper.MapCalculation(request);
ForecastResponseDto responseDto = await _orchestrator.Orchestration(requestDto);
CalculateResponse response = _responseMapper.MapCalculationResponse(responseDto);
return(Ok(response));
}
var errors = MapModelValidationErrors(ModelState);
return(BadRequest(new CalculateResponse(errors)));
}
catch (Exception ex)
{
//logging
return(BadRequest(new CalculateResponse(new List <string>()
{
"Exception"
})));
}
}
public void AndLumpSum10000AndMonthlyInvestment1000_ThenReturnCorrectValuesForYear7()
{
//Arrange
ForecastRequestDto request = _builder
.WithValidDefaults()
.WithInvestmentTerm(7)
.Build();
var expectedWideLowerBound = 97679.80m;
var expectedWideUpperBound = 123197.17m;
var expectedNarrowLowerBound = 101513.10m;
var expectedNarrowUpperBound = 109664.16m;
var expectedTotalInvested = 94000m;
//Assert
var actual = Calculate(request);
//Act
Assert.AreEqual(expectedWideLowerBound, actual.ElementAt(7).TotalValueWideLower, "Wide lower");
Assert.AreEqual(expectedWideUpperBound, actual.ElementAt(7).TotalValueWideUpper, "Wide upper");
Assert.AreEqual(expectedNarrowLowerBound, actual.ElementAt(7).TotalValueNarrowLower, "Narrow lower");
Assert.AreEqual(expectedNarrowUpperBound, actual.ElementAt(7).TotalValueNarrowUpper, "Narrow upper");
Assert.AreEqual(expectedTotalInvested, actual.ElementAt(7).TotalInvestmentAmount, "Total invested");
}
public void AndLumpSum10000AndMonthlyInvestment1000_ThenReturnCorrectValuesForYear10()
{
//Arrange
ForecastRequestDto request = _builder
.WithValidDefaults()
.WithInvestmentTerm(10)
.Build();
var expectedWideLowerBound = 130000m;
var expectedWideUpperBound = 170652.14m;
var expectedNarrowLowerBound = 140918.66m;
var expectedNarrowUpperBound = 157126.98m;
var expectedTotalInvested = 130000m;
//Assert
var actual = Calculate(request);
//Act
Assert.AreEqual(expectedWideLowerBound, actual.ElementAt(10).TotalValueWideLower, "Wide lower");
Assert.AreEqual(expectedWideUpperBound, actual.ElementAt(10).TotalValueWideUpper, "Wide upper");
Assert.AreEqual(expectedNarrowLowerBound, actual.ElementAt(10).TotalValueNarrowLower, "Narrow lower");
Assert.AreEqual(expectedNarrowUpperBound, actual.ElementAt(10).TotalValueNarrowUpper, "Narrow upper");
Assert.AreEqual(expectedTotalInvested, actual.ElementAt(10).TotalInvestmentAmount, "Total invested");
}
public CalculateResponse Calculate(CalculateRequest request)
{
ForecastRequestDto requestDto = _requestMapper.MapCalculation(request);
ForecastResponseDto responseDto = _orchestrator.CalculateAnnualGrowth(requestDto);
return(_responseMapper.MapCalculationResponse(responseDto));
}
private async Task <HttpResponseMessage> PostDTOAndGetResponse(ForecastRequestDto dto, string route)
{
var jsonContent = new StringContent(JsonConvert.SerializeObject(dto),
Encoding.Default, "application/json");
return(await _client.PostAsync(route, jsonContent));
}
public Result <IEnumerable <WeatherForecast> > GetForecast(ForecastRequestDto model)
{
if (model.PostalCode == "NotFound")
{
return(Result <IEnumerable <WeatherForecast> > .NotFound());
}
// validate model
if (model.PostalCode.Length > 10)
{
return(Result <IEnumerable <WeatherForecast> > .Invalid(new Dictionary <string, string> {
{ "PostalCode", "PostalCode cannot exceed 10 characters." }
}));
}
var rng = new Random();
return(new Result <IEnumerable <WeatherForecast> >(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray()));
}
public async Task ReturnsNotFoundGivenNonExistentPostalCode(string route)
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "NotFound"
};
var response = await PostDTOAndGetResponse(requestDto, route);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task ReturnsBadRequestGivenNoPostalCode(string route)
{
var requestDto = new ForecastRequestDto()
{
PostalCode = ""
};
var response = await PostDTOAndGetResponse(requestDto, route);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task ReturnsNotFoundGivenNonExistentPostalCode()
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "NotFound"
};
var jsonContent = new StringContent(JsonConvert.SerializeObject(requestDto), Encoding.Default, "application/json");
var response = await _client.PostAsync("/weatherforecast", jsonContent);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task ReturnsBadRequestGivenPostalCodeTooLong(string route)
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "01234567890"
};
var response = await PostDTOAndGetResponse(requestDto, route);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var stringResponse = await response.Content.ReadAsStringAsync();
Assert.Contains("PostalCode cannot exceed 10 characters.", stringResponse);
}
public async Task ReturnsOkWithValueGivenValidPostalCode(string route)
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "55555"
};
var response = await PostDTOAndGetResponse(requestDto, route);
response.EnsureSuccessStatusCode();
var stringResponse = await response.Content.ReadAsStringAsync();
var forecasts = JsonConvert.DeserializeObject <List <WeatherForecast> >(stringResponse);
Assert.Equal("Freezing", forecasts.First().Summary);
}
public async Task ReturnsBadRequestGivenPostalCodeTooLong()
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "01234567890"
};
var jsonContent = new StringContent(JsonConvert.SerializeObject(requestDto), Encoding.Default, "application/json");
var response = await _client.PostAsync("/weatherforecast", jsonContent);
//response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var stringResponse = await response.Content.ReadAsStringAsync();
Assert.Contains("PostalCode cannot exceed 10 characters.", stringResponse);
}
public async Task ReturnsOkWithValueGivenValidPostalCode()
{
var requestDto = new ForecastRequestDto()
{
PostalCode = "55555"
};
var jsonContent = new StringContent(JsonConvert.SerializeObject(requestDto), Encoding.Default, "application/json");
var response = await _client.PostAsync("/weatherforecast", jsonContent);
response.EnsureSuccessStatusCode();
var stringResponse = await response.Content.ReadAsStringAsync();
var forecasts = JsonConvert.DeserializeObject <List <WeatherForecast> >(stringResponse);
Assert.Equal("Freezing", forecasts.First().Summary);
}
public Result <IEnumerable <WeatherForecast> > GetForecast(ForecastRequestDto model)
{
if (model.PostalCode == "NotFound")
{
return(Result <IEnumerable <WeatherForecast> > .NotFound());
}
// validate model
if (model.PostalCode.Length > 10)
{
return(Result <IEnumerable <WeatherForecast> > .Invalid(new List <ValidationError> {
new ValidationError
{
Identifier = nameof(model.PostalCode),
ErrorMessage = _stringLocalizer["PostalCode cannot exceed 10 characters."].Value
}
}));
}
// test value
if (model.PostalCode == "55555")
{
return(new Result <IEnumerable <WeatherForecast> >(Enumerable.Range(1, 1)
.Select(index =>
new WeatherForecast
{
Date = DateTime.Now,
TemperatureC = 0,
Summary = Summaries[0]
})));
}
var rng = new Random();
return(new Result <IEnumerable <WeatherForecast> >(Enumerable.Range(1, 5)
.Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray()));
}
public void AndLumpSum10000AndMonthlyInvestment1000_ThenReturnCorrectValuesForYear0()
{
//Arrange
ForecastRequestDto request = _builder
.WithValidDefaults()
.Build();
var expectedAmount = request.LumpSumInvestment;
//Assert
var actual = Calculate(request);
//Act
Assert.AreEqual(expectedAmount, actual.ElementAt(0).TotalValueWideLower, "Wide lower");
Assert.AreEqual(expectedAmount, actual.ElementAt(0).TotalValueWideUpper, "Wide upper");
Assert.AreEqual(expectedAmount, actual.ElementAt(0).TotalValueNarrowLower, "Narrow lower");
Assert.AreEqual(expectedAmount, actual.ElementAt(0).TotalValueNarrowUpper, "Narrow upper");
Assert.AreEqual(expectedAmount, actual.ElementAt(0).TotalValueNarrowUpper, "Total invested");
}
public Result <IEnumerable <WeatherForecast> > GetForecast([FromBody] ForecastRequestDto model)
{
return(_weatherService.GetForecast(model));
// var result = _weatherService.GetForecast(model);
// if (result.Status == ResultStatus.NotFound) return NotFound();
// if (result.Status == ResultStatus.Invalid)
// {
// foreach (var error in result.ValidationErrors)
// {
// ModelState.AddModelError(error.Key, error.Value);
// }
// return BadRequest(ModelState);
// }
//
// return Ok(result.Value);
// TODO: Write a filter or helper so we can make this one line of code
// Either return _weatherService.GetForecast(model); and use filter
// or
// return GetActionResult(_weatherService.GetForecast(model)); using a helper
}
public Task <Result <IEnumerable <WeatherForecast> > > GetForecastAsync(ForecastRequestDto model)
{
return(Task.FromResult(GetForecast(model)));
}
public override ActionResult <IEnumerable <WeatherForecast> > Handle(ForecastRequestDto request)
{
return(this.ToActionResult(_weatherService.GetForecast(request)));
}
private IEnumerable <AnnualForecast> Calculate(ForecastRequestDto request)
{
return(_forecastCalculator.Calculate(new MediumRiskBounds(), request));
}
public Result <IEnumerable <WeatherForecast> > CreateForecast([FromBody] ForecastRequestDto model)
{
return(_weatherService.GetForecast(model));
}
public IEnumerable <string> Validate(ForecastRequestDto request)
{
//perform any business validation
return(new List <string>());
}
