public async Task UpdatePackageAsync_UnsuccessfulRequest_ShouldThrowFactroApiException()
{
// Arrange
var projectId = Guid.NewGuid().ToString();
var packageId = Guid.NewGuid().ToString();
var updateProjectRequest = new UpdatePackageRequest();
var expectedResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
RequestMessage = new HttpRequestMessage
{
RequestUri = new Uri("http://www.mock-web-address.com"),
},
};
var packageApi = this.fixture.GetPackageApi(expectedResponse);
// Act
Func <Task> act = async() => await packageApi.UpdatePackageAsync(projectId, packageId, updateProjectRequest);
// Assert
await act.Should().ThrowAsync <FactroApiException>();
}
public async Task UpdatePackageAsync_ValidRequest_ShouldReturnUpdatePackage()
{
// Arrange
var existingProject = new GetProjectPayload
{
Id = Guid.NewGuid().ToString(),
};
var existingPackage = new GetPackagePayload
{
Id = Guid.NewGuid().ToString(),
Description = "TestDescription",
};
var updatePackageRequest = new UpdatePackageRequest
{
Description = "NewDescription",
};
var expectedUpdatedPackage = new UpdatePackageResponse
{
Id = existingPackage.Id,
Description = updatePackageRequest.Description,
};
var expectedResponseContent = new StringContent(JsonConvert.SerializeObject(expectedUpdatedPackage, this.fixture.JsonSerializerSettings));
var expectedResponse = new HttpResponseMessage
{
Content = expectedResponseContent,
};
var packageApi = this.fixture.GetPackageApi(expectedResponse);
var updatePackageResponse = new UpdatePackageResponse();
// Act
Func <Task> act = async() =>
updatePackageResponse = await packageApi.UpdatePackageAsync(existingProject.Id, existingPackage.Id, updatePackageRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
updatePackageResponse.Id.Should().Be(existingPackage.Id);
updatePackageResponse.Description.Should().Be(expectedUpdatedPackage.Description);
}
}
public async Task <HttpResponseMessage> UpdatePackage(UpdatePackageRequest updatePackageRequest)
{
httpResponseMessage = new HttpResponseMessage();
if (updatePackageRequest != null && ModelState.IsValid)
{
var getUserInvoiceResponse = await _IAccountService.UpdatePackage(updatePackageRequest);
httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, getUserInvoiceResponse);
}
else
{
httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, new { Message = CustomErrorMessages.INVALID_INPUTS, Success = false });
}
return(httpResponseMessage);
}
public async Task UpdatePackageAsync_InvalidPackageId_ShouldThrowArgumentNullException(string packageId)
{
// Arrange
var existingProject = new GetProjectPayload
{
Id = Guid.NewGuid().ToString(),
};
var updatePackageRequest = new UpdatePackageRequest
{
Description = "NewDescription",
};
var packageApi = this.fixture.GetPackageApi();
// Act
Func <Task> act = async() => await packageApi.UpdatePackageAsync(existingProject.Id, packageId, updatePackageRequest);
// Assert
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task <IActionResult> UpdatePackage([FromBody] UpdatePackageRequest package)
{
if (package == null)
{
throw new Exception("Invalid Package");
}
var input = new UpdatePackageInput()
{
Id = package.Id,
Name = package.Name,
Products = package.Products.Select(p => new ProductInput()
{
Id = p.Id,
Name = p.Name,
ProductType = p.ProductType
}).ToList()
};
await _updatePackagesInput.Process(input);
return(Ok());
}
public async Task <BaseResponse> UpdatePackage(UpdatePackageRequest updatePackageRequest)
{
return(await _IAccountRepository.UpdatePackage(updatePackageRequest));
}
public async Task <UpdatePackageResponse> UpdatePackageAsync(string projectId, string packageId, UpdatePackageRequest updatePackageRequest)
{
if (string.IsNullOrWhiteSpace(projectId))
{
throw new ArgumentNullException(nameof(projectId), $"{nameof(projectId)} can not be null, empty or whitespace.");
}
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentNullException(nameof(packageId), $"{nameof(packageId)} can not be null, empty or whitespace.");
}
if (updatePackageRequest == null)
{
throw new ArgumentNullException(nameof(updatePackageRequest), $"{nameof(updatePackageRequest)} can not be null.");
}
var requestRoute = PackageApiEndpoints.Base.Update(projectId, packageId);
var requestString = JsonConvert.SerializeObject(updatePackageRequest, this.jsonSerializerSettings);
var requestContent = ApiHelpers.GetStringContent(requestString);
var response = await this.httpClient.PutAsync(requestRoute, requestContent);
if (!response.IsSuccessStatusCode)
{
throw new FactroApiException(
$"Could not update package with id '{packageId}' of project with id '{projectId}'.",
response.RequestMessage.RequestUri.ToString(),
response.StatusCode,
response.Content == null ? null : await response.Content.ReadAsStringAsync());
}
var responseContentString = await response.Content.ReadAsStringAsync();
var result =
JsonConvert.DeserializeObject <UpdatePackageResponse>(
responseContentString,
this.jsonSerializerSettings);
return(result);
}
public async Task <ActionResult> Update([FromRoute] Guid cateringId, [FromRoute] Guid packageId, [FromBody] UpdatePackageRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorType = "Bad Request",
StatusCode = 400,
Errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)
}));
}
var package = new Package
{
Id = packageId,
Name = request.Name,
Serves = request.Serves,
ServicePresentation = request.ServicePresentation,
SetupTime = request.SetupTime,
Description = request.Description,
Price = request.Price,
Menus = request.Menus.Select(m => new Menu
{
Id = m.Id,
Name = m.Name
}).ToList(),
PackageRequirements = request.PackageRequirements.Select(p => new PackageRequirement
{
Id = p.Id,
Name = p.Name
}).ToList(),
PackageOptions = request.PackageOptions.Select(p => new PackageOption
{
Id = p.Id,
OptionsType = p.OptionsType,
Title = p.Title,
PackageOptionItems = p.PackageOptionItems.Select(pi => new PackageOptionItem
{
Id = pi.Id,
Name = pi.Name
}).ToList()
}).ToList()
};
var updated = await packageService.UpdatePackageAsync(package, cateringId);
if (updated)
{
return(Ok(new PackageResponse
{
Id = package.Id,
Name = package.Name,
Description = package.Description,
Serves = package.Serves,
Price = package.Price,
ServicePresentation = package.ServicePresentation,
SetupTime = package.SetupTime,
Menus = package.Menus.Select(m => new MenuResponse
{
Id = m.Id,
Name = m.Name
}),
PackageOptions = package.PackageOptions.Select(p => new PackageOptionResponse
{
Id = p.Id,
OptionsType = p.OptionsType,
PackageOptionItems = p.PackageOptionItems.Select(pi => new PackageOptionItemResponse
{
Id = pi.Id,
Name = pi.Name
}),
Title = p.Title
}),
PackageRequirements = package.PackageRequirements.Select(p => new PackageRequirementResponse
{
Id = p.Id,
Name = p.Name
})
}));
}
return(NotFound(new ApiErrorResponse()
{
ErrorType = "Not Found",
StatusCode = 404,
Errors = new[] { "Package not found." }
}));
}
