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;
}
