public async Task FailsIfOneConfigsInCollectionIsInvalid()
{
var max = 4;
var sample = new SampleConfig
{
ListOfConfigs = new List <ListConfig>
{
new ListConfig {
Name = "item one", Value = 5
},
new ListConfig {
Name = "item two", Value = 2
}
}
};
modelBuilder.Collection(p => p.ListOfConfigs)
.Property(p => p.Value)
.WithMaxValue(max);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.GreaterThanMax(nameof(ListConfig.Value), max), result.Errors.Single());
}
public static bool ValidateString(ValidationStrings strings, string data)
{
switch (strings)
{
case ValidationStrings.Username: // Username must be at least 4 chars (maybe add settings to tweak these later on)
if (string.IsNullOrWhiteSpace(data) || data.Length < 4)
{
return(false);
}
break;
case ValidationStrings.Password: // pass must be at least 4 chars
if (string.IsNullOrWhiteSpace(data) || data.Length < 4)
{
return(false);
}
break;
case ValidationStrings.EmailAddress: // Is actually an email address
if (string.IsNullOrWhiteSpace(data) || !data.IsValidEmail())
{
return(false);
}
break;
case ValidationStrings.EmailVerificationCode: // Provided token's length must much whichever the length is on our side
if (string.IsNullOrWhiteSpace(data) || data.Length < EmailToken.Length)
{
return(false);
}
break;
case ValidationStrings.GoogleAuthenticatorCode:
if (string.IsNullOrWhiteSpace(data) || data.Length < 6 || !IsDigitsOnly(data))
{
return(false);
}
break;
case ValidationStrings.CharFirstName:
if (string.IsNullOrWhiteSpace(data) || data.Length < 2 || data.Length > 15 || !Regex.Match(data, @"[a-zA-Z]{1,15}").Success)
{
return(false);
}
break;
case ValidationStrings.CharLastName:
if (string.IsNullOrWhiteSpace(data) || data.Length < 2 || data.Length > 15 || !Regex.Match(data, @"[a-zA-Z]{1,15}").Success)
{
return(false);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(strings), strings, null);
}
return(true);
}
public async Task FailsIfNull()
{
var model = modelBuilder.Build();
var result = await target.Validate(null, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.InvalidConfigType(model.Type), result.Errors.Single());
}
public async Task FailsIfLessthanMin_nullable_int()
{
var min = 3;
var sample = new SampleConfig
{
SpareLlamaCapacity = 2
};
modelBuilder.Property(k => k.SpareLlamaCapacity).WithMinValue(min);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.LessThanMin(nameof(SampleConfig.SpareLlamaCapacity), min), result.Errors.Single());
}
public async Task FailsIfPatternDoesNotMatch()
{
var pattern = @"^\d{3}";
var sample = new SampleConfig
{
Name = "9wt20"
};
modelBuilder.Property(k => k.Name).WithPattern(pattern);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.MatchesPattern(nameof(SampleConfig.Name), pattern), result.Errors.Single());
}
public async Task FailsIfGreaterThanMax_date()
{
var max = new DateTime(2013, 10, 10);
var sample = new SampleConfig
{
StartDate = max.AddDays(1)
};
modelBuilder.Property(k => k.StartDate).WithMaxValue(max);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.GreaterThanMax(nameof(SampleConfig.StartDate), max), result.Errors.Single());
}
public async Task FailsIfGreaterThanLength()
{
var max = 3;
var sample = new SampleConfig
{
Name = "Four"
};
modelBuilder.Property(k => k.Name).WithMaxLength(max);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.GreaterThanMaxLength(nameof(SampleConfig.Name), max), result.Errors.Single());
}
public async Task FailsIfGreaterThanMax_decimal()
{
var max = 3m;
var sample = new SampleConfig
{
Decimal = 4m
};
modelBuilder.Property(k => k.Decimal).WithMaxValue(max);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.GreaterThanMax(nameof(SampleConfig.Decimal), max), result.Errors.Single());
}
public async Task FailsIfLessthanMin_date()
{
var min = new DateTime(2013, 10, 10);
var sample = new SampleConfig
{
StartDate = min.AddDays(-1)
};
modelBuilder.Property(k => k.StartDate).WithMinValue(min);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.LessThanMin(nameof(SampleConfig.StartDate), min), result.Errors.Single());
}
public async Task FailsIfLessthanMin_decimal()
{
var min = 3m;
var sample = new SampleConfig
{
Decimal = 2m
};
modelBuilder.Property(k => k.Decimal).WithMinValue(min);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.LessThanMin(nameof(SampleConfig.Decimal), min), result.Errors.Single());
}
public async Task FailsIfGreaterThanMax_int()
{
var max = 3;
var sample = new SampleConfig
{
LlamaCapacity = 4
};
modelBuilder.Property(k => k.LlamaCapacity).WithMaxValue(max);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Equal(1, result.Errors.Count());
Assert.Equal(ValidationStrings.GreaterThanMax(nameof(SampleConfig.LlamaCapacity), max), result.Errors.Single());
}
public async Task FailsIfOptionNotAvailable()
{
var sample = new SampleConfig
{
OptionFromConfigSet = new OptionFromConfigSet {
Id = 5, Description = "Option Four"
}
};
modelBuilder.PropertyWithOption(p => p.OptionFromConfigSet, (SampleConfigSet provider) => provider.Options);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.OptionNotFound(nameof(SampleConfig.OptionFromConfigSet)), result.Errors.Single());
}
public async Task FailsIfOneOptionNotAvailable()
{
var sample = new SampleConfig
{
MoarOptions = new List <Option>
{
new Option {
Id = 5, Description = "Option Four"
},
OptionProvider.OptionOne
}
};
modelBuilder.PropertyWithMultipleOptions(p => p.MoarOptions, (SampleConfigSet provider) => provider.Options);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Equal(1, result.Errors.Count());
Assert.Equal(ValidationStrings.OptionNotFound(nameof(SampleConfig.MoarOptions)), result.Errors.Single());
}
public async Task FailsIfDuplicateKeysInCollection()
{
var sample = new SampleConfig
{
ListOfConfigs = new List <ListConfig>
{
new ListConfig {
Name = "item one", Value = 2
},
new ListConfig {
Name = "item two", Value = 2
}
}
};
modelBuilder.Collection(p => p.ListOfConfigs)
.WithUniqueKey(p => p.Value);
var model = modelBuilder.Build();
var result = await target.Validate(sample, model, configIdentity);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.Equal(ValidationStrings.DuplicateKeys(nameof(SampleConfig.ListOfConfigs), 2), result.Errors.Single());
}
