public static void ToModelErrors_ReturnsExpectedResult( string field, string id, AggregateValidationResult aggregateResult) { var expectedKey = $"[0].{field}"; var expectedErrors = new (string, string)[]
public static async Task CreateAsync_CatalogueItemSavedToDb( [Frozen] ApplicationDbContext context, [Frozen] Mock <ICreateOrderItemValidator> orderItemValidator, [Frozen] Mock <IServiceRecipientService> serviceRecipientService, Order order, CatalogueItemId catalogueItemId, CreateOrderItemModel model, CreateOrderItemService service) { context.Order.Add(order); await context.SaveChangesAsync(); var aggregateValidationResult = new AggregateValidationResult(); aggregateValidationResult.AddValidationResult(new ValidationResult(), 0); var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, true); var serviceRecipients = model.ServiceRecipients.Select(r => new ServiceRecipient(r.OdsCode, r.Name)); orderItemValidator.Setup(o => o.Validate(order, model, catalogueItemType)).Returns(aggregateValidationResult); serviceRecipientService.Setup(r => r.AddOrUpdateServiceRecipients(It.IsAny <IEnumerable <ServiceRecipient> >())) .ReturnsAsync(serviceRecipients.ToDictionary(r => r.OdsCode)); await service.CreateAsync(order, catalogueItemId, model); var expectedOrderItem = context.Set <OrderItem>().First(o => o.CatalogueItem.Id.Equals(catalogueItemId)); expectedOrderItem.CatalogueItem.Name.Should().Be(model.CatalogueItemName); }
public static async Task CreateAsync_RemovesDefaultDeliveryDate( [Frozen] ApplicationDbContext context, [Frozen] Mock <ICreateOrderItemValidator> orderItemValidator, [Frozen] Mock <IServiceRecipientService> serviceRecipientService, Order order, CatalogueItemId catalogueItemId, CreateOrderItemModel model, CreateOrderItemService service) { order.SetDefaultDeliveryDate(catalogueItemId, DateTime.Now.AddDays(10)); context.Order.Add(order); await context.SaveChangesAsync(); order.DefaultDeliveryDates.Should().NotBeEmpty(); var aggregateValidationResult = new AggregateValidationResult(); aggregateValidationResult.AddValidationResult(new ValidationResult(), 0); var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, true); var serviceRecipients = model.ServiceRecipients.Select(r => new ServiceRecipient(r.OdsCode, r.Name)); orderItemValidator.Setup(o => o.Validate(order, model, catalogueItemType)).Returns(aggregateValidationResult); serviceRecipientService.Setup(r => r.AddOrUpdateServiceRecipients(It.IsAny <IEnumerable <ServiceRecipient> >())) .ReturnsAsync(serviceRecipients.ToDictionary(r => r.OdsCode)); await service.CreateAsync(order, catalogueItemId, model); var defaultDeliveryDateResult = context.Set <DefaultDeliveryDate>().FirstOrDefault(d => d.OrderId.Equals(order.Id)); defaultDeliveryDateResult.Should().BeNull(); }
public async Task ValidateAsync_WhenRequirePackageSignatureIsTrue_RequiresPackageSignatureFile( bool includePackageSignatureFile) { var storage = new MemoryStorage(_baseUri); var now = GetDateTime(); var storageContent = CreateStorageContent(now, includePackageSignatureFile); storage.Content.TryAdd(_packageDetailsUri, storageContent); using (var clientHandler = new MockServerHttpClientHandler()) using (CollectorHttpClient client = await CreateCollectorHttpClientStubAsync(clientHandler, storage)) { ValidationContext context = CreateContext(client, now); CatalogAggregateValidator validator = CreateValidator(context, requirePackageSignature: true); AggregateValidationResult result = await validator.ValidateAsync(context); Assert.Single(result.ValidationResults); var expectedResult = includePackageSignatureFile ? TestResult.Pass : TestResult.Fail; var actualResult = result.ValidationResults.Single(); Assert.Equal(expectedResult, actualResult.Result); if (includePackageSignatureFile) { Assert.Null(actualResult.Exception); } else { Assert.IsType <MissingPackageSignatureFileException>(actualResult.Exception); } } }
public static async Task CreateOrderItemsAsync_ValidationFailure_ReturnsExpectedResponse( ErrorDetails errorDetails, AggregateValidationResult aggregateValidationResult, [Frozen] Mock <ICreateOrderItemService> createOrderItemService, [Frozen] Mock <IOrderItemService> orderItemService, [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, Order order, CreateOrderItemModel model, OrderItemsController controller) { controller.ProblemDetailsFactory = new TestProblemDetailsFactory(); aggregateValidationResult.AddValidationResult(new ValidationResult(errorDetails), 0); Expression <Func <ICreateOrderItemService, Task <AggregateValidationResult> > > createAsync = s => s.CreateAsync( It.Is <Order>(o => o.Equals(order)), It.Is <CatalogueItemId>(i => i == catalogueItemId), It.Is <CreateOrderItemModel>(m => m == model)); orderItemService.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order); createOrderItemService.Setup(createAsync).ReturnsAsync(aggregateValidationResult); var response = await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); response.Should().BeOfType <BadRequestObjectResult>(); response.As <BadRequestObjectResult>().Value.Should().BeOfType <ValidationProblemDetails>(); }
public static async Task CreateOrderItemAsync_ValidationFailure_AddsModelErrors( [Frozen] IReadOnlyList <ErrorDetails> errorDetails, AggregateValidationResult aggregateValidationResult, [Frozen] Mock <ICreateOrderItemService> createOrderItemService, [Frozen] Mock <IOrderItemService> orderItemService, [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, Order order, CreateOrderItemModel model, OrderItemsController controller) { controller.ProblemDetailsFactory = new TestProblemDetailsFactory(); aggregateValidationResult.AddValidationResult(new ValidationResult(errorDetails), 0); Expression <Func <ICreateOrderItemService, Task <AggregateValidationResult> > > createAsync = s => s.CreateAsync( It.Is <Order>(o => o.Equals(order)), It.Is <CatalogueItemId>(i => i == catalogueItemId), It.Is <CreateOrderItemModel>(m => m == model)); orderItemService.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order); createOrderItemService.Setup(createAsync).ReturnsAsync(aggregateValidationResult); await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); var modelState = controller.ModelState; modelState.ErrorCount.Should().Be(errorDetails.Count); modelState.Keys.Should().BeEquivalentTo(errorDetails.Select(e => e.ParentName + "[0]." + e.Field)); var modelStateErrors = modelState.Values.Select(v => v.Errors[0].ErrorMessage); modelStateErrors.Should().BeEquivalentTo(errorDetails.Select(e => e.Id)); }
public static void Success_SuccessfulResultsOnly_IsTrue( ValidationResult result, AggregateValidationResult aggregateResult) { aggregateResult.AddValidationResult(result, 0); aggregateResult.Success.Should().BeTrue(); }
public void Constructor_maps_arguments() { var results = new List <ValidationResult>(); var aggregateResult = new AggregateValidationResult("New aggregate", results); aggregateResult.AggregateName.Should().Be("New aggregate"); aggregateResult.MemberNames.Should().HaveCount(1); aggregateResult.Results.Equals(results); }
public static void Success_FailedResults_IsFalse( ErrorDetails error, AggregateValidationResult aggregateResult) { var result = new ValidationResult(error); aggregateResult.AddValidationResult(result, 0); aggregateResult.Success.Should().BeFalse(); }
public static void AssertAggregateValidationResult(AggregateValidationResult expected, AggregateValidationResult actual) { if (expected == null) { Assert.Null(actual); return; } AssertFieldEqual(expected, actual, i => i.AggregateValidator.Name); AssertFieldEqual(expected, actual, i => i.ValidationResults, AssertValidationResult); }
public static void AddValidationResult_CombinesExistingResults( ErrorDetails error1, ErrorDetails error2, AggregateValidationResult aggregateResult) { var result1 = new ValidationResult(error1); var result2 = new ValidationResult(error2); aggregateResult.AddValidationResult(result1, 0); aggregateResult.AddValidationResult(result2, 0); aggregateResult.FailedValidations.Should().HaveCount(1); }
public static async Task CreateAsync_ValidAggregateValidation_SuccessIsTrue( [Frozen] Mock <ICreateOrderItemValidator> orderItemValidator, Order order, CatalogueItemId catalogueItemId, CreateOrderItemModel model, CreateOrderItemService service) { var aggregateValidationResult = new AggregateValidationResult(); aggregateValidationResult.AddValidationResult(new ValidationResult(), 0); var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, true); orderItemValidator.Setup(o => o.Validate(order, model, catalogueItemType)).Returns(aggregateValidationResult); var result = await service.CreateAsync(order, catalogueItemId, model); result.Success.Should().BeTrue(); }
public AggregateValidationResult Validate(Order order, CreateOrderItemModel model, CatalogueItemType itemType) { if (order.CommencementDate is null) { throw new ArgumentNullException(nameof(order), $"{nameof(order)}.{nameof(Order.CommencementDate)} should not be null."); } var aggregateValidationResult = new AggregateValidationResult(); var itemIndex = -1; foreach (var recipient in model.ServiceRecipients) { itemIndex++; aggregateValidationResult.AddValidationResult( new ValidationResult(ValidateDeliveryDate(recipient.DeliveryDate, order.CommencementDate.Value, itemType)), itemIndex); } return(aggregateValidationResult); }
public async Task ValidateAsync_WhenRequirePackageSignatureIsFalse_DoesNotRequirePackageSignatureFile( bool includePackageSignatureFile) { var storage = new MemoryStorage(_baseUri); var now = GetDateTime(); var storageContent = CreateStorageContent(now, includePackageSignatureFile); storage.Content.TryAdd(_packageDetailsUri, storageContent); using (var clientHandler = new MockServerHttpClientHandler()) using (CollectorHttpClient client = await CreateCollectorHttpClientStubAsync(clientHandler, storage)) { ValidationContext context = CreateContext(client, now); CatalogAggregateValidator validator = CreateValidator(context, requirePackageSignature: false); AggregateValidationResult result = await validator.ValidateAsync(context); Assert.Empty(result.ValidationResults); } }
public void Invalid() { var validationResults = new ValidationResult[] { new ValidationResult(null, TestResult.Fail) }; var aggregateValidationResults = new AggregateValidationResult( null, validationResults); var packageValidationResult = new PackageValidationResult( new PackageIdentity("testPackage", new NuGetVersion(4, 5, 6)), null, null, new AggregateValidationResult[] { aggregateValidationResults }); var status = new PackageMonitoringStatus(packageValidationResult); Assert.Equal(PackageState.Invalid, status.State); }
public static void AddValidationResult_NullResult_ThrowsException(AggregateValidationResult aggregateResult) { Assert.Throws <ArgumentNullException>(() => aggregateResult.AddValidationResult(null, 0)); }