public async Task DropsMessageOnDuplicateValidationRequest() { var messageData = new PackageValidationMessageData("packageId", "1.2.3", Guid.NewGuid()); var validationConfiguration = new ValidationConfiguration(); var package = new Package(); var packageValidatingEntity = new PackageValidatingEntity(package); CorePackageServiceMock .Setup(ps => ps.FindPackageByIdAndVersionStrict(messageData.PackageId, messageData.PackageVersion)) .Returns(packageValidatingEntity) .Verifiable(); ValidationSetProviderMock .Setup(vsp => vsp.TryGetOrCreateValidationSetAsync(messageData, packageValidatingEntity)) .ReturnsAsync((PackageValidationSet)null) .Verifiable(); var handler = CreateHandler(); var result = await handler.HandleAsync(messageData); Assert.True(result); CorePackageServiceMock .Verify(ps => ps.FindPackageByIdAndVersionStrict(messageData.PackageId, messageData.PackageVersion), Times.Once()); ValidationSetProviderMock .Verify(vsp => vsp.TryGetOrCreateValidationSetAsync(messageData, packageValidatingEntity), Times.Once()); }
public ValidationSetProviderFacts() { ValidationStorageMock = new Mock <IValidationStorageService>(MockBehavior.Strict); ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >(); LoggerMock = new Mock <ILogger <ValidationSetProvider> >(); Configuration = new ValidationConfiguration(); ConfigurationAccessorMock .SetupGet(ca => ca.Value) .Returns(() => Configuration); Package = new Package { PackageRegistration = new PackageRegistration { Id = "package1" }, Version = "1.2.3.456", NormalizedVersion = "1.2.3", Key = 42, }; Package.PackageRegistration.Packages = new List <Package> { Package }; ValidationSet = new PackageValidationSet { PackageId = Package.PackageRegistration.Id, PackageNormalizedVersion = Package.NormalizedVersion, ValidationTrackingId = Guid.NewGuid() }; }
public async Task WaitsForPackageAvailabilityInGalleryDBWithProcessValidationSet() { var messageData = PackageValidationMessageData.NewProcessValidationSet( "packageId", "1.2.3", Guid.NewGuid(), ValidatingType.Package, entityKey: null); var validationConfiguration = new ValidationConfiguration(); CorePackageServiceMock .Setup(ps => ps.FindPackageByIdAndVersionStrict( messageData.ProcessValidationSet.PackageId, messageData.ProcessValidationSet.PackageVersion)) .Returns <Package>(null) .Verifiable(); var handler = CreateHandler(); await handler.HandleAsync(messageData); CorePackageServiceMock.Verify( ps => ps.FindPackageByIdAndVersionStrict( messageData.ProcessValidationSet.PackageId, messageData.ProcessValidationSet.PackageVersion), Times.Once); }
public void ConfigurationValidatorBehavesWellOnUnconnectedGraph() { var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = "Validation1", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>() }, new ValidationConfigurationItem { Name = "Validation2", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>() } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.Null(ex); }
public Facts(ITestOutputHelper output) { Options = new Mock <IOptionsSnapshot <ValidationConfiguration> >(); EntityService = new Mock <IEntityService <TestEntity> >(); ValidationSetProvider = new Mock <IValidationSetProvider <TestEntity> >(); ValidationSetProcessor = new Mock <IValidationSetProcessor>(); ValidationOutcomeProcessor = new Mock <IValidationOutcomeProcessor <TestEntity> >(); LeaseService = new Mock <ILeaseService>(); PackageValidationEnqueuer = new Mock <IPackageValidationEnqueuer>(); FeatureFlagService = new Mock <IFeatureFlagService>(); TelemetryService = new Mock <ITelemetryService>(); Logger = new LoggerFactory().AddXunit(output).CreateLogger <SymbolValidationMessageHandler>(); Config = new ValidationConfiguration { MissingPackageRetryCount = 1, }; ValidatingEntity = new Mock <IValidatingEntity <TestEntity> >(); ValidationSet = new PackageValidationSet { PackageKey = 42, ValidationTrackingId = new Guid("dc2aa638-a23c-4791-a4ff-c3e07b1320a4"), PackageId = "NuGet.Versioning", PackageNormalizedVersion = "5.3.0-BETA", ValidatingType = ValidatingType.Package, ValidationSetStatus = ValidationSetStatus.InProgress, }; LeaseResourceName = "Package/nuget.versioning/5.3.0-beta"; ValidationSetProcessorResult = new ValidationSetProcessorResult(); LeaseResult = LeaseResult.Success("lease-id"); Options.Setup(x => x.Value).Returns(() => Config); EntityService .Setup(x => x.FindPackageByKey(It.IsAny <int>())) .Returns(() => ValidatingEntity.Object); ValidationSetProcessor .Setup(x => x.ProcessValidationsAsync(It.IsAny <PackageValidationSet>())) .ReturnsAsync(() => ValidationSetProcessorResult); ValidatingEntity .Setup(x => x.Status) .Returns(PackageStatus.Validating); LeaseService .Setup(x => x.TryAcquireAsync(It.IsAny <string>(), It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => LeaseResult); FeatureFlagService.Setup(x => x.IsQueueBackEnabled()).Returns(true); FeatureFlagService.Setup(x => x.IsOrchestratorLeaseEnabled()).Returns(true); Target = new TestHandler( Options.Object, EntityService.Object, ValidationSetProvider.Object, ValidationSetProcessor.Object, ValidationOutcomeProcessor.Object, LeaseService.Object, PackageValidationEnqueuer.Object, FeatureFlagService.Object, TelemetryService.Object, Logger); }
public void ConfigurationValidatorDetectsDuplicates() { const string validationName = "Validation1"; var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = validationName, FailAfter = TimeSpan.FromHours(1), }, new ValidationConfigurationItem { Name = validationName, FailAfter = TimeSpan.FromHours(1), } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.IsType <ConfigurationErrorsException>(ex); Assert.Contains("duplicate", ex.Message, StringComparison.OrdinalIgnoreCase); Assert.Contains(validationName, ex.Message, StringComparison.OrdinalIgnoreCase); }
public UserManager(StoreConfiguration <TUser, TClaim, TLogin> storeCollection, ValidationConfiguration <TUser> validationConfiguration, ILogger logger) { if (storeCollection == null) { throw new ArgumentNullException(nameof(storeCollection)); } if (storeCollection.Validate() != null) { throw new ArgumentNullException(storeCollection.Validate()); } if (validationConfiguration == null) { throw new ArgumentNullException(nameof(validationConfiguration)); } if (validationConfiguration.Validate() != null) { throw new ArgumentNullException(validationConfiguration.Validate()); } UserStore = storeCollection.UserStore; PasswordStore = storeCollection.PasswordStore; EmailStore = storeCollection.EmailStore; ClaimStore = storeCollection.ClaimStore; TokenStore = storeCollection.TokenStore; LockoutStore = storeCollection.LockoutStore; ValidationConfiguration = validationConfiguration; Logger = logger; }
public void ConfigurationValidatorSmokeTest() { var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = "Validation1", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation2" } }, new ValidationConfigurationItem { Name = "Validation2", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>() } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.Null(ex); }
public async Task DropsMessageIfPackageIsSoftDeletedForProcessValidationSet() { var messageData = PackageValidationMessageData.NewProcessValidationSet( "packageId", "1.2.3", Guid.NewGuid(), ValidatingType.Package, entityKey: null); var validationConfiguration = new ValidationConfiguration(); var package = new Package { PackageStatusKey = PackageStatus.Deleted }; var packageValidatingEntity = new PackageValidatingEntity(package); CorePackageServiceMock .Setup(ps => ps.FindPackageByIdAndVersionStrict( messageData.ProcessValidationSet.PackageId, messageData.ProcessValidationSet.PackageVersion)) .Returns(packageValidatingEntity); var handler = CreateHandler(); var result = await handler.HandleAsync(messageData); Assert.True(result); CorePackageServiceMock.Verify( ps => ps.FindPackageByIdAndVersionStrict( messageData.ProcessValidationSet.PackageId, messageData.ProcessValidationSet.PackageVersion), Times.Once); }
public void ConfigurationValidatorDetectsLoops() { var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = "Validation1", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation2" } }, new ValidationConfigurationItem { Name = "Validation2", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation1" } } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.IsType <ConfigurationErrorsException>(ex); Assert.Contains("loop", ex.Message, StringComparison.OrdinalIgnoreCase); }
public async Task DropsMessageIfPackageIsSoftDeletedForCheckValidator() { var messageData = PackageValidationMessageData.NewCheckValidator(Guid.NewGuid()); var validationConfiguration = new ValidationConfiguration(); var package = new Package { Key = 42, PackageStatusKey = PackageStatus.Deleted }; var packageValidatingEntity = new PackageValidatingEntity(package); var validationSet = new PackageValidationSet { PackageKey = package.Key, ValidatingType = ValidatingType.Package }; ValidationSetProviderMock .Setup(ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId)) .ReturnsAsync(validationSet) .Verifiable(); CorePackageServiceMock .Setup(ps => ps.FindPackageByKey(package.Key)) .Returns(packageValidatingEntity); var handler = CreateHandler(); var result = await handler.HandleAsync(messageData); Assert.True(result); ValidationSetProviderMock.Verify( vsp => vsp.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId), Times.Once); CorePackageServiceMock.Verify( ps => ps.FindPackageByKey(package.Key), Times.Once); }
public async Task WaitsForPackageAvailabilityInGalleryDBWithCheckValidator() { var messageData = PackageValidationMessageData.NewCheckValidator(Guid.NewGuid()); var validationConfiguration = new ValidationConfiguration(); var validationSet = new PackageValidationSet { PackageKey = 42, ValidatingType = ValidatingType.SymbolPackage }; ValidationSetProviderMock .Setup(ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId)) .ReturnsAsync(validationSet) .Verifiable(); CoreSymbolPackageServiceMock .Setup(ps => ps.FindPackageByKey(validationSet.PackageKey)) .Returns <SymbolPackage>(null) .Verifiable(); var handler = CreateHandler(); var result = await handler.HandleAsync(messageData); ValidationSetProviderMock.Verify( ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId), Times.Once); CoreSymbolPackageServiceMock.Verify( ps => ps.FindPackageByKey(validationSet.PackageKey), Times.Once); Assert.False(result, "The handler should not have succeeded."); }
public void TestFixtureSetUp() { _testViewModel = new TestViewModel(); _validationConfiguration = new ValidationConfiguration(); var convention0 = new DefaultPropertyConvention(x => !x.Name.StartsWith("Optional")); convention0.AddValidationRule <IsRequired <CanBeAnyViewModel> >(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention0); var convention1 = new DefaultPropertyConvention(x => x.Name.Contains("Url")); convention1.AddValidationRule <IsUrl <CanBeAnyViewModel> >(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention1); var convention2 = new DefaultPropertyConvention(x => x.Name.Contains("Email")); convention2.AddValidationRule <IsEmail <CanBeAnyViewModel> >(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention2); _validationConfiguration.DiscoveredTypes.AddDiscoveredType <TestViewModel>(); IValidationResults <TestViewModel> validationResults = _validationConfiguration.Validate(_testViewModel); _testViewModel.ValidationResults.CloneFrom(validationResults); _testView = new TestView(); _testView.SetModel(_testViewModel); }
public ValidationOutcomeProcessorFacts() { PackageServiceMock = new Mock <ICorePackageService>(); PackageFileServiceMock = new Mock <ICorePackageFileService>(); ValidationEnqueuerMock = new Mock <IPackageValidationEnqueuer>(); ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >(); MessageServiceMock = new Mock <IMessageService>(); LoggerMock = new Mock <ILogger <ValidationOutcomeProcessor> >(); Configuration = new ValidationConfiguration(); Configuration.Validations = new List <ValidationConfigurationItem>(); Package = new Package { PackageRegistration = new PackageRegistration { Id = "package" }, Version = "1.2.3.456", NormalizedVersion = "1.2.3", PackageStatusKey = PackageStatus.Validating }; Package.PackageRegistration.Packages.Add(Package); ValidationSet = new PackageValidationSet(); ValidationSet.PackageValidations = new List <PackageValidation>(); ValidationSet.PackageId = Package.PackageRegistration.Id; ValidationSet.PackageNormalizedVersion = Package.NormalizedVersion; ValidationSet.ValidationTrackingId = Guid.NewGuid(); ConfigurationAccessorMock .SetupGet(ca => ca.Value) .Returns(Configuration); }
protected ValidationSetProcessorFactsBase( MockBehavior validatorProviderMockBehavior = MockBehavior.Default, MockBehavior validationStorageMockBehavior = MockBehavior.Default, MockBehavior configurationAccessorMockBehavior = MockBehavior.Default, MockBehavior packageFileServiceMockBehavior = MockBehavior.Default, MockBehavior loggerMockBehavior = MockBehavior.Default) { ValidatorProviderMock = new Mock <IValidatorProvider>(validatorProviderMockBehavior); ValidationStorageMock = new Mock <IValidationStorageService>(validationStorageMockBehavior); ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >(configurationAccessorMockBehavior); PackageFileServiceMock = new Mock <ICorePackageFileService>(packageFileServiceMockBehavior); LoggerMock = new Mock <ILogger <ValidationSetProcessor> >(loggerMockBehavior); Configuration = new ValidationConfiguration { Validations = new List <ValidationConfigurationItem> { } }; ConfigurationAccessorMock .SetupGet(ca => ca.Value) .Returns(Configuration); Package = new Package { PackageRegistration = new PackageRegistration { Id = "packageId" }, Version = "1.2.3.456", NormalizedVersion = "1.2.3" }; Package.PackageRegistration.Packages.Add(Package); ValidationSet = new PackageValidationSet { Key = 238423, PackageId = Package.PackageRegistration.Id, PackageNormalizedVersion = Package.NormalizedVersion, PackageValidations = new List <PackageValidation> { } }; ValidationSet.PackageValidations.ToList().ForEach(v => v.PackageValidationSet = ValidationSet); Validators = new Dictionary <string, Mock <IValidator> >(); PackageFileServiceMock .Setup(pfs => pfs.GetValidationPackageReadUriAsync(It.IsAny <Package>(), It.IsAny <DateTimeOffset>())) .Returns <Package, DateTimeOffset>( (p, e) => Task.FromResult(new Uri($"https://example.com/{ValidationContainerName}/{p.PackageRegistration.Id}/{p.NormalizedVersion}?e={e:yyyy-MM-dd-hh-mm-ss}"))); PackageFileServiceMock .Setup(pfs => pfs.GetPackageReadUriAsync(It.IsAny <Package>())) .Returns <Package>( p => Task.FromResult(new Uri($"https://example.com/{PublicContainerName}/{p.PackageRegistration.Id}/{p.NormalizedVersion}"))); PackageFileServiceMock .Setup(pfs => pfs.DoesValidationPackageFileExistAsync(Package)) .ReturnsAsync(true); }
public void ConfigurationValidatorDetectsRequiredValidationsThatHasNoChanceToRun(ValidationFailureBehavior lastValidationFailureBehavior, int numIntermediateValidations, ValidationFailureBehavior intermediateValidationsFailureBehavior) { // If validation that must succeed depends on validation that is not going to be started // that validation would have no chance to run, failing all the validations. // So we need to detect such situations early const string firstValidationName = "FirstValidation"; const string lastValidationName = "LastValidation"; var configuration = new ValidationConfiguration { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = firstValidationName, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>(), ShouldStart = false } } }; var previousValidationName = firstValidationName; foreach (var intermediateValidationIndex in Enumerable.Range(1, numIntermediateValidations)) { var intermediateValidationName = $"Validation{intermediateValidationIndex}"; configuration.Validations.Add(new ValidationConfigurationItem { Name = intermediateValidationName, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { previousValidationName }, ShouldStart = true, FailureBehavior = intermediateValidationsFailureBehavior }); previousValidationName = intermediateValidationName; } configuration.Validations.Add(new ValidationConfigurationItem { Name = lastValidationName, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { previousValidationName }, ShouldStart = true, FailureBehavior = lastValidationFailureBehavior }); configuration.Validations.Reverse(); var ex = Record.Exception(() => Validate(configuration)); Assert.NotNull(ex); Assert.Contains(firstValidationName, ex.Message); Assert.Contains("cannot be run", ex.Message, StringComparison.OrdinalIgnoreCase); }
private static void Validate(ValidationConfiguration configuration) { var optionsAccessor = new Mock <IOptionsSnapshot <ValidationConfiguration> >(); optionsAccessor.SetupGet(cfg => cfg.Value).Returns(configuration); var validator = new ConfigurationValidator(optionsAccessor.Object); validator.Validate(); }
public static ValidationConfiguration AddFluentValidation(this ValidationConfiguration config) { var assemblies = GetAssembliesForSolution(); ScanForValidators(config.Services, assemblies); config.Services.AddScoped <ValidationProvider>(); config.Repository.Add(typeof(ValidationProvider)); return(config); }
public ValidationConfig() { var validatorConfiguration = new ValidationConfiguration(); var validationDsl = new ValidationDsl(validatorConfiguration); Configure(validationDsl); new StructureMapConfigurer(validatorConfiguration).ConfigureRegistry(this); }
private static void Validate(ValidationConfiguration configuration) { var validatorProvider = new Mock <IValidatorProvider>(); validatorProvider .Setup(x => x.IsValidator(It.IsAny <string>())) .Returns(true); Validate(validatorProvider.Object, configuration); }
public ValidationSetProviderFacts() { ValidationStorageMock = new Mock <IValidationStorageService>(MockBehavior.Strict); PackageFileServiceMock = new Mock <IValidationPackageFileService>(MockBehavior.Strict); ValidatorProvider = new Mock <IValidatorProvider>(MockBehavior.Strict); ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >(); TelemetryServiceMock = new Mock <ITelemetryService>(); LoggerMock = new Mock <ILogger <ValidationSetProvider> >(); PackageFileServiceMock .Setup(x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>())) .ReturnsAsync(() => ETag); PackageFileServiceMock .Setup(x => x.CopyValidationPackageForValidationSetAsync(It.IsAny <PackageValidationSet>())) .Returns(Task.CompletedTask); PackageFileServiceMock .Setup(x => x.BackupPackageFileFromValidationSetPackageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>())) .Returns(Task.CompletedTask); ValidatorProvider .Setup(x => x.IsProcessor(It.IsAny <string>())) .Returns(true); Configuration = new ValidationConfiguration(); ConfigurationAccessorMock .SetupGet(ca => ca.Value) .Returns(() => Configuration); ETag = "\"some-etag\""; Package = new Package { PackageRegistration = new PackageRegistration { Id = "package1" }, Version = "1.2.3.456", NormalizedVersion = "1.2.3", Key = 42, Created = new DateTime(2010, 1, 2, 8, 30, 0, DateTimeKind.Utc), PackageStatusKey = PackageStatus.Validating, }; Package.PackageRegistration.Packages = new List <Package> { Package }; ValidationSet = new PackageValidationSet { PackageId = Package.PackageRegistration.Id, PackageNormalizedVersion = Package.NormalizedVersion, PackageKey = Package.Key, ValidationTrackingId = Guid.NewGuid(), }; }
protected static ValidationProvider CreateValidationProvider() { var validationConfiguration = new ValidationConfiguration() { SameUsernameAttemptsPeriodLimit = 2, MultipleUsernameAttemptsPeriodLimit = 2, UserNameAttemptsLimit = 2 }; return(new ValidationProvider(validationConfiguration)); }
public static IServiceCollection AddFormValidation(this IServiceCollection instance, Action <ValidationConfiguration> config = null) { var repository = new ValidationProviderRepository(); instance.AddScoped <IValidationProviderRepository>((_) => repository); if (config != null) { var c = new ValidationConfiguration(instance, repository); config(c); } return(instance); }
public void ConfigurationValidatorTreatsDepencyGraphAsOriented2() { /* Validation1 * / \ * / \ * v v * Validation2 Validation3 * \ / * \ / * v v * Validation4 */ var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = "Validation1", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation2", "Validation3" } }, new ValidationConfigurationItem { Name = "Validation2", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation4" } }, new ValidationConfigurationItem { Name = "Validation3", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { "Validation4" } }, new ValidationConfigurationItem { Name = "Validation4", FailAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>() } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.Null(ex); }
public void ConfigurationValidatorDetectsParallelProcessors() { var validationName1 = "Validation1"; var validationName2 = "Validation2"; var processorName1 = "Processor1"; var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = validationName1, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>(), }, new ValidationConfigurationItem { Name = validationName2, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { validationName1 }, }, new ValidationConfigurationItem { Name = processorName1, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { validationName1 }, }, } }; var validatorProvider = new Mock <IValidatorProvider>(); validatorProvider .Setup(x => x.IsValidator(It.Is <string>(n => n == validationName1 || n == validationName2 || n == processorName1))) .Returns(true); validatorProvider .Setup(x => x.IsProcessor(processorName1)) .Returns(true); var ex = Record.Exception(() => Validate(validatorProvider.Object, configuration)); Assert.IsType <ConfigurationErrorsException>(ex); Assert.Contains( "The processor Processor1 could run in parallel with Validation2. Processors must not run in parallel with any other validators.", ex.Message); }
private static IValidator <int> GetInstance(Action <ValidationConfiguration <object, int> > configAction) { IValidator <int> validator = null; var mockSink = new Mock <IComponentSink <IValidator <int> > >(); var config = new ValidationConfiguration <object, int>(null, mockSink.Object); mockSink.Setup(m => m.Sink(It.IsAny <IValidator <int> >())) .Callback <IValidator <int> >(component => validator = Validator.Combine(validator, component)); configAction(config); return(validator); }
public void ConfigurationValidatorAllowsNonParallelProcessors() { var validationName1 = "Validation1"; var validationName2 = "Validation2"; var processorName1 = "Processor1"; var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = validationName1, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string>(), }, new ValidationConfigurationItem { Name = validationName2, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { validationName1 }, }, new ValidationConfigurationItem { Name = processorName1, TrackAfter = TimeSpan.FromHours(1), RequiredValidations = new List <string> { validationName2 }, }, } }; var validatorProvider = new Mock <IValidatorProvider>(); validatorProvider .Setup(x => x.IsValidator(It.Is <string>(n => n == validationName1 || n == validationName2 || n == processorName1))) .Returns(true); validatorProvider .Setup(x => x.IsProcessor(processorName1)) .Returns(true); var ex = Record.Exception(() => Validate(validatorProvider.Object, configuration)); Assert.Null(ex); }
public void TestResultEmptyWhenNoViolations() { var events = TestsBase.GetEvents(@"Logs\noviolations.xml"); var validationConfiguration = new ValidationConfiguration() { SameUsernameAttemptsPeriodLimit = 1, MultipleUsernameAttemptsPeriodLimit = 1, UserNameAttemptsLimit = 1 }; var validationProvider = new ValidationProvider(validationConfiguration); var validationCollection = validationProvider.Validate(events); Assert.IsEmpty(validationCollection); }
public static void RegisterServices(IServiceCollection services) { ContextConfiguration.Register(services); BusConfiguration.Register(services); EventConfiguration.Register(services); ValidationConfiguration.Register(services); HandlerConfiguration.Register(services); ServiceConfiguration.Register(services); RepositoryConfiguration.Register(services); // Infra - Identity Services //services.AddTransient<IEmailSender, AuthEmailMessageSender>(); //services.AddTransient<ISmsSender, AuthSMSMessageSender>(); // Infra - Identity //services.AddScoped<IUser, AspNetUser>(); }
public void FailureTimeoutsCantBeZero() { var configuration = new ValidationConfiguration() { Validations = new List <ValidationConfigurationItem> { new ValidationConfigurationItem { Name = "SomeValidation", FailAfter = TimeSpan.Zero } } }; var ex = Record.Exception(() => Validate(configuration)); Assert.IsType <ConfigurationErrorsException>(ex); Assert.Contains("FailAfter", ex.Message, StringComparison.OrdinalIgnoreCase); }
public void SetUp() { _testViewModel = new TestViewModel(); _validationConfiguration = new ValidationConfiguration(); }
public void SetUp() { _validationConfiguration = new ValidationConfiguration(); _validationDsl = new ValidationDsl(_validationConfiguration); }
public void TestFixtureSetUp() { _testViewModel = new TestViewModel(); _validationConfiguration = new ValidationConfiguration(); var convention0 = new DefaultPropertyConvention(x => !x.Name.StartsWith("Optional")); convention0.AddValidationRule<IsRequired<CanBeAnyViewModel>>(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention0); var convention1 = new DefaultPropertyConvention(x => x.Name.Contains("Url")); convention1.AddValidationRule<IsUrl<CanBeAnyViewModel>>(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention1); var convention2 = new DefaultPropertyConvention(x => x.Name.Contains("Email")); convention2.AddValidationRule<IsEmail<CanBeAnyViewModel>>(); _validationConfiguration.DefaultPropertyConventions.AddDefaultPropertyConvention(convention2); _validationConfiguration.DiscoveredTypes.AddDiscoveredType<TestViewModel>(); IValidationResults<TestViewModel> validationResults = _validationConfiguration.Validate(_testViewModel); _testViewModel.ValidationResults.CloneFrom(validationResults); _testView = new TestView(); _testView.SetModel(_testViewModel); }
public StructureMapConfigurer(ValidationConfiguration validationConfigurationOld) { _validationConfiguration = validationConfigurationOld; }