public void empty_client_validation_rules_are_not_created()
{
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2"));
var assertRule = assert.GetClientValidationRules().Single();
Assert.False(assertRule.ValidationParameters.ContainsKey("fieldsmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("constsmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("parsersmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("errfieldsmap"));
Assert.True(assertRule.ValidationParameters.ContainsKey("expression"));
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("1 > 2"));
var requirRule = requir.GetClientValidationRules().Single();
Assert.False(requirRule.ValidationParameters.ContainsKey("fieldsmap"));
Assert.False(requirRule.ValidationParameters.ContainsKey("constsmap"));
Assert.False(requirRule.ValidationParameters.ContainsKey("parsersmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("errfieldsmap"));
Assert.True(requirRule.ValidationParameters.ContainsKey("allowempty"));
Assert.True(requirRule.ValidationParameters.ContainsKey("expression"));
}
public void client_validation_rules_are_json_formatting_insensitive()
{
var settings = JsonConvert.DefaultSettings;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Array);
var controllerContext = GetControllerContext();
const string expression = "Value > 0 && Status == ValidatorsTest.State.High && InsensString == NInsensString";
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute(expression));
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("{\"Value\":\"numeric\",\"Status\":\"numeric\",\"InsensString\":\"stringinsens\",\"NInsensString\":\"stringinsens\"}", (string)assertRule.ValidationParameters["fieldsmap"], false);
Assert.Equal("{\"ValidatorsTest.State.High\":0}", (string)assertRule.ValidationParameters["constsmap"], false);
Assert.Equal("{\"Array\":\"arrayparser\"}", (string)assertRule.ValidationParameters["parsersmap"], false);
Assert.Equal("\"Value > 0 && Status == ValidatorsTest.State.High && InsensString == NInsensString\"", (string)assertRule.ValidationParameters["expression"], false);
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute(expression));
var requirRule = requir.GetClientValidationRules().Single();
Assert.Equal("{\"Value\":\"numeric\",\"Status\":\"numeric\",\"InsensString\":\"stringinsens\",\"NInsensString\":\"stringinsens\"}", (string)requirRule.ValidationParameters["fieldsmap"], false);
Assert.Equal("{\"ValidatorsTest.State.High\":0}", (string)requirRule.ValidationParameters["constsmap"], false);
Assert.Equal("{\"Array\":\"arrayparser\"}", (string)assertRule.ValidationParameters["parsersmap"], false);
Assert.Equal("false", (string)requirRule.ValidationParameters["allowempty"], false);
Assert.Equal("\"Value > 0 && Status == ValidatorsTest.State.High && InsensString == NInsensString\"", (string)requirRule.ValidationParameters["expression"], false);
JsonConvert.DefaultSettings = settings; // reset settings to original state
}
public void client_validation_rules_are_json_formatting_insensitive()
{
var settings = JsonConvert.DefaultSettings;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var model = new Model {
Value = 1, Status = State.High
};
var metadata = GetModelMetadata(model);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("Value > 0 && Status == ValidatorsTest.State.High"));
var assertRule = assert.GetClientValidationRules().Single();
Assert.AreEqual("{\"Value\":\"numeric\",\"Status\":\"numeric\"}", (string)assertRule.ValidationParameters["fieldsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("{\"ValidatorsTest.State.High\":0}", (string)assertRule.ValidationParameters["constsmap"], false, CultureInfo.InvariantCulture);
// expression is not a json actually, but tested for the sake of clarity
Assert.AreEqual("Value > 0 && Status == ValidatorsTest.State.High", (string)assertRule.ValidationParameters["expression"], false, CultureInfo.InvariantCulture);
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("Value > 0 && Status == ValidatorsTest.State.High"));
var requirRule = requir.GetClientValidationRules().Single();
Assert.AreEqual("{\"Value\":\"numeric\",\"Status\":\"numeric\"}", (string)requirRule.ValidationParameters["fieldsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("{\"ValidatorsTest.State.High\":0}", (string)requirRule.ValidationParameters["constsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("false", (string)requirRule.ValidationParameters["allowempty"], false, CultureInfo.InvariantCulture);
// expression is not a json actually, but tested for the sake of clarity
Assert.AreEqual("Value > 0 && Status == ValidatorsTest.State.High", (string)requirRule.ValidationParameters["expression"], false, CultureInfo.InvariantCulture);
JsonConvert.DefaultSettings = settings; // reset settings to original state
}
public void verify_that_culture_change_affects_message_sent_to_client()
{
var model = new MsgModel();
var metadata = GetModelMetadata(model, m => m.Lang);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "{Lang:n}"
});
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("default", assertRule.ErrorMessage);
// change culture
var culture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("pl");
// simulate next request - create new validator
assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "{Lang:n}"
});
assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("polski", assertRule.ErrorMessage);
// restore culture
Thread.CurrentThread.CurrentUICulture = culture;
}
public void verify_that_culture_change_affects_message_sent_to_client()
{
var model = new MsgModel();
var metadata = GetModelMetadata(model, m => m.Lang);
var controllerContext = GetControllerContext();
CulturalExecutionUI(() =>
{
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "{Lang:n}"
});
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("default", assertRule.ErrorMessage);
}, "en");
// simulate next request - create new validator
CulturalExecutionUI(() =>
{
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "{Lang:n}"
});
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("polski", assertRule.ErrorMessage);
}, "pl");
}
public void client_validation_rules_are_json_formatting_insensitive()
{
var settings = JsonConvert.DefaultSettings;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var model = new Model {Value = 1, Status = State.High};
var metadata = GetModelMetadata(model);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("Value > 0 && Status == ValidatorsTest.State.High"));
var assertRule = assert.GetClientValidationRules().Single();
Assert.AreEqual("{\"Value\":\"numeric\",\"Status\":\"numeric\"}", (string)assertRule.ValidationParameters["fieldsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("{\"ValidatorsTest.State.High\":0}", (string)assertRule.ValidationParameters["constsmap"], false, CultureInfo.InvariantCulture);
// expression is not a json actually, but tested for the sake of clarity
Assert.AreEqual("Value > 0 && Status == ValidatorsTest.State.High", (string)assertRule.ValidationParameters["expression"], false, CultureInfo.InvariantCulture);
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("Value > 0 && Status == ValidatorsTest.State.High"));
var requirRule = requir.GetClientValidationRules().Single();
Assert.AreEqual("{\"Value\":\"numeric\",\"Status\":\"numeric\"}", (string)requirRule.ValidationParameters["fieldsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("{\"ValidatorsTest.State.High\":0}", (string)requirRule.ValidationParameters["constsmap"], false, CultureInfo.InvariantCulture);
Assert.AreEqual("false", (string)requirRule.ValidationParameters["allowempty"], false, CultureInfo.InvariantCulture);
// expression is not a json actually, but tested for the sake of clarity
Assert.AreEqual("Value > 0 && Status == ValidatorsTest.State.High", (string)requirRule.ValidationParameters["expression"], false, CultureInfo.InvariantCulture);
JsonConvert.DefaultSettings = settings; // reset settings to original state
}
public void empty_client_validation_rules_are_not_created()
{
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2"));
var assertRule = assert.GetClientValidationRules().Single();
Assert.False(assertRule.ValidationParameters.ContainsKey("fieldsmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("constsmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("parsersmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("errfieldsmap"));
Assert.True(assertRule.ValidationParameters.ContainsKey("expression"));
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("1 > 2"));
var requirRule = requir.GetClientValidationRules().Single();
Assert.False(requirRule.ValidationParameters.ContainsKey("fieldsmap"));
Assert.False(requirRule.ValidationParameters.ContainsKey("constsmap"));
Assert.False(requirRule.ValidationParameters.ContainsKey("parsersmap"));
Assert.False(assertRule.ValidationParameters.ContainsKey("errfieldsmap"));
Assert.True(requirRule.ValidationParameters.ContainsKey("allowempty"));
Assert.True(requirRule.ValidationParameters.ContainsKey("expression"));
}
public void verify_client_validation_rules()
{
var model = new Model();
var assertAttributes = Enumerable.Range(0, 28).Select(x => new AssertThatAttribute(string.Format("Value > {0}", x))).ToArray();
var requirAttributes = Enumerable.Range(0, 28).Select(x => new RequiredIfAttribute(string.Format("Value > {0}", x))).ToArray();
var metadata = GetModelMetadata(model);
var controllerContext = GetControllerContext();
try
{
for (var i = 0; i < assertAttributes.Length; i++)
{
var attribute = assertAttributes[i];
var validator = new AssertThatValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.AreEqual(string.Format("assertthat{0}", suffix), rule.ValidationType);
}
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.Message);
}
try
{
for (var i = 0; i < requirAttributes.Length; i++)
{
var attribute = requirAttributes[i];
var validator = new RequiredIfValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.AreEqual(string.Format("requiredif{0}", suffix), rule.ValidationType);
}
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.Message);
}
}
public void verify_client_validation_rules_collecting_for_multiple_annotations()
{
var model = new Model();
var assertAttributes = Enumerable.Range(0, 28).Select(x => new AssertThatAttribute($"Value > {x}")).ToArray();
var requirAttributes = Enumerable.Range(0, 28).Select(x => new RequiredIfAttribute($"Value > {x}")).ToArray();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws <ValidationException>(() =>
{
for (var i = 0; i < assertAttributes.Length; i++)
{
var attribute = assertAttributes[i];
var validator = new AssertThatValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.Equal($"assertthat{suffix}", rule.ValidationType);
}
});
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType <InvalidOperationException>(e.InnerException);
Assert.Equal(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.InnerException.Message);
e = Assert.Throws <ValidationException>(() =>
{
for (var i = 0; i < requirAttributes.Length; i++)
{
var attribute = requirAttributes[i];
var validator = new RequiredIfValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.Equal($"requiredif{suffix}", rule.ValidationType);
}
});
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType <InvalidOperationException>(e.InnerException);
Assert.Equal(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.InnerException.Message);
}
public void verify_formatted_message_sent_to_client()
{
var model = new MsgModel();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "_{0}{1}{Value:n}{Value:N}{Value}{Value}_{{Value}}{{{Value}}}{{{{Value}}}}_"
});
var assertRule = assert.GetClientValidationRules().Single();
var map = JsonConvert.DeserializeObject<dynamic>((string) assertRule.ValidationParameters["errfieldsmap"]);
var expected = "_Value1 > 2_{Value}__{Value}_" + map.Value + map.Value + "_{Value}" + "{" + map.Value + "}" + "{{Value}}_";
Assert.Equal(expected, assertRule.ErrorMessage);
}
public void verify_client_validation_rules_collecting()
{
var model = new Model();
var assertAttributes = Enumerable.Range(0, 28).Select(x => new AssertThatAttribute($"Value > {x}")).ToArray();
var requirAttributes = Enumerable.Range(0, 28).Select(x => new RequiredIfAttribute($"Value > {x}")).ToArray();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws<ValidationException>(() =>
{
for (var i = 0; i < assertAttributes.Length; i++)
{
var attribute = assertAttributes[i];
var validator = new AssertThatValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.Equal($"assertthat{suffix}", rule.ValidationType);
}
});
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<InvalidOperationException>(e.InnerException);
Assert.Equal(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.InnerException.Message);
e = Assert.Throws<ValidationException>(() =>
{
for (var i = 0; i < requirAttributes.Length; i++)
{
var attribute = requirAttributes[i];
var validator = new RequiredIfValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.Equal($"requiredif{suffix}", rule.ValidationType);
}
});
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<InvalidOperationException>(e.InnerException);
Assert.Equal(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.InnerException.Message);
}
public void AddValidation(ClientModelValidationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Use the HttpContext to inject the MemoryCache into the validator, since we can't inject it in the constructor of
// ValidationAttribute...see https://andrewlock.net/injecting-services-into-validationattributes-in-asp-net-core/
var processCache = context.ActionContext.HttpContext.RequestServices.GetService <IMemoryCache>();
var requestCache = context.ActionContext.HttpContext.RequestServices.GetService <RequestCache>();
var validator = new AssertThatValidator(context.ModelMetadata, this, processCache, requestCache);
validator.AttachValidationRules(context, DefaultErrorMessage);
}
public void verify_client_validation_rules_collecting_for_separate_model_items()
{
var models = Enumerable.Range(0, 28).Select(x => new Model()).ToArray();
var controllerContext = GetControllerContext();
foreach (var model in models)
{
var metadata = GetModelMetadata(model, m => m.Value);
var assertThatValidator = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("Value > 0"));
var rule = assertThatValidator.GetClientValidationRules().Single();
Assert.Equal("assertthat", rule.ValidationType);
var requiredIfValidator = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("Value > 0"));
rule = requiredIfValidator.GetClientValidationRules().Single();
Assert.Equal("requiredif", rule.ValidationType);
}
}
public void verify_client_validation_rules_collecting_for_multiple_models_with_single_annotation()
{
var models = Enumerable.Range(0, 28).Select(x => new Model()).ToList();
var controllerContext = GetControllerContext();
models.ForEach(model =>
{
var metadata = GetModelMetadata(model, m => m.Value);
var validator = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("Value > 0"));
var rule = validator.GetClientValidationRules().Single();
Assert.Equal("assertthat", rule.ValidationType);
});
models.ForEach(model =>
{
var metadata = GetModelMetadata(model, m => m.Value);
var validator = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("Value > 0"));
var rule = validator.GetClientValidationRules().Single();
Assert.Equal("requiredif", rule.ValidationType);
});
}
public void throw_for_client_validation_rules_collecting_when_no_httpcontext_is_available()
{
var model = new Model();
var assertAttribute = new AssertThatAttribute("true");
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var context = HttpContext.Current;
var e = Assert.Throws<ValidationException>(() =>
{
var validator = new AssertThatValidator(metadata, controllerContext, assertAttribute);
HttpContext.Current = null;
validator.GetClientValidationRules().Single();
});
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
HttpContext.Current = context;
e = Assert.Throws<ValidationException>(() =>
{
var validator = new RequiredIfValidator(metadata, controllerContext, requirAttribute);
HttpContext.Current = null;
validator.GetClientValidationRules().Single();
});
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
}
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
var rules = new List <ModelClientValidationRule>();
var property = metadata.ContainerType.GetProperty(metadata.PropertyName);
var assertThatAttributeType = typeof(AssertThatAttribute);
if (IsDefined(property, assertThatAttributeType))
{
var provider = new AssertThatValidator(metadata, context, (AssertThatAttribute)GetCustomAttribute(property, assertThatAttributeType));
rules.AddRange(provider.GetClientValidationRules());
}
var requiredIfAttributeType = typeof(RequiredIfAttribute);
if (IsDefined(property, requiredIfAttributeType))
{
var provider = new RequiredIfValidator(metadata, context, (RequiredIfAttribute)GetCustomAttribute(property, requiredIfAttributeType));
rules.AddRange(provider.GetClientValidationRules());
}
return(rules);
}
public void client_validation_rules_are_json_formatting_insensitive()
{
var settings = JsonConvert.DefaultSettings;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Array);
var controllerContext = GetControllerContext();
const string expression = "Value > 0 && MathModel.PI == 3.142 && Status == ValidatorsTest.State.High && SubModel.InsensString == NInsensString";
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute(expression));
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("{\"Value\":\"number\",\"Status\":\"enumeration\",\"SubModel.InsensString\":\"stringinsens\",\"NInsensString\":\"stringinsens\"}", (string) assertRule.ValidationParameters["fieldsmap"], false);
Assert.Equal("{\"MathModel.PI\":3.142}", (string) assertRule.ValidationParameters["constsmap"], false);
Assert.Equal("{\"ValidatorsTest.State.High\":0}", (string) assertRule.ValidationParameters["enumsmap"], false);
Assert.Equal("{\"SubModel.InsensString\":\"stringparser\",\"Array\":\"arrayparser\"}", (string) assertRule.ValidationParameters["parsersmap"], false);
Assert.Equal("\"Value > 0 && MathModel.PI == 3.142 && Status == ValidatorsTest.State.High && SubModel.InsensString == NInsensString\"", (string) assertRule.ValidationParameters["expression"], false);
var requir = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute(expression));
var requirRule = requir.GetClientValidationRules().Single();
Assert.Equal("{\"Value\":\"number\",\"Status\":\"enumeration\",\"SubModel.InsensString\":\"stringinsens\",\"NInsensString\":\"stringinsens\"}", (string) requirRule.ValidationParameters["fieldsmap"], false);
Assert.Equal("{\"MathModel.PI\":3.142}", (string) requirRule.ValidationParameters["constsmap"], false);
Assert.Equal("{\"ValidatorsTest.State.High\":0}", (string) requirRule.ValidationParameters["enumsmap"], false);
Assert.Equal("{\"SubModel.InsensString\":\"stringparser\",\"Array\":\"arrayparser\"}", (string) assertRule.ValidationParameters["parsersmap"], false);
Assert.Equal("false", (string) requirRule.ValidationParameters["allowempty"], false);
Assert.Equal("\"Value > 0 && MathModel.PI == 3.142 && Status == ValidatorsTest.State.High && SubModel.InsensString == NInsensString\"", (string) requirRule.ValidationParameters["expression"], false);
JsonConvert.DefaultSettings = settings; // reset settings to original state
}
public void throw_for_client_validation_rules_collecting_when_no_httpcontext_is_available()
{
var model = new Model();
var assertAttribute = new AssertThatAttribute("true");
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var context = HttpContext.Current;
var e = Assert.Throws<ValidationException>(() =>
{
var validator = new AssertThatValidator(metadata, controllerContext, assertAttribute);
HttpContext.Current = null;
validator.GetClientValidationRules().Single();
});
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal("HttpContext not available.", e.InnerException.Message);
HttpContext.Current = context;
e = Assert.Throws<ValidationException>(() =>
{
var validator = new RequiredIfValidator(metadata, controllerContext, requirAttribute);
HttpContext.Current = null;
validator.GetClientValidationRules().Single();
});
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal("HttpContext not available.", e.InnerException.Message);
}
public void verify_client_validation_rules()
{
var model = new Model();
var assertAttributes = Enumerable.Range(0, 28).Select(x => new AssertThatAttribute(string.Format("Value > {0}", x))).ToArray();
var requirAttributes = Enumerable.Range(0, 28).Select(x => new RequiredIfAttribute(string.Format("Value > {0}", x))).ToArray();
var metadata = GetModelMetadata(model);
var controllerContext = GetControllerContext();
try
{
for (var i = 0; i < assertAttributes.Length; i++)
{
var attribute = assertAttributes[i];
var validator = new AssertThatValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.AreEqual(string.Format("assertthat{0}", suffix), rule.ValidationType);
}
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.Message);
}
try
{
for (var i = 0; i < requirAttributes.Length; i++)
{
var attribute = requirAttributes[i];
var validator = new RequiredIfValidator(metadata, controllerContext, attribute);
var rule = validator.GetClientValidationRules().Single();
var suffix = i == 0 ? string.Empty : char.ConvertFromUtf32(96 + i);
Assert.AreEqual(string.Format("requiredif{0}", suffix), rule.ValidationType);
}
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"No more than 27 unique attributes of the same type can be applied for a single field or property.",
e.Message);
}
}
public void verify_formatted_message_sent_to_client()
{
var model = new MsgModel();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2")
{
ErrorMessage = "_{0}{1}{Value:n}{Value:N}{Value}{Value}_{{Value}}{{{Value}}}{{{{Value}}}}_"
});
var assertRule = assert.GetClientValidationRules().Single();
var map = JsonConvert.DeserializeObject<dynamic>((string) assertRule.ValidationParameters["errfieldsmap"]);
var expected = "_Value1 > 2_{Value}__{Value}_" + map.Value + map.Value + "_{Value}" + "{" + map.Value + "}" + "{{Value}}_";
Assert.Equal(expected, assertRule.ErrorMessage);
}
public void verify_that_culture_change_affects_message_sent_to_client()
{
var model = new MsgModel();
var metadata = GetModelMetadata(model, m => m.Lang);
var controllerContext = GetControllerContext();
var assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2") {ErrorMessage = "{Lang:n}"});
var assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("default", assertRule.ErrorMessage);
// change culture
var culture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("pl");
// simulate next request - create new validator
assert = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("1 > 2") {ErrorMessage = "{Lang:n}"});
assertRule = assert.GetClientValidationRules().Single();
Assert.Equal("polski", assertRule.ErrorMessage);
// restore culture
Thread.CurrentThread.CurrentUICulture = culture;
}
public void verify_client_validation_rules_collecting_for_multiple_models_with_single_annotation()
{
var models = Enumerable.Range(0, 28).Select(x => new Model()).ToList();
var controllerContext = GetControllerContext();
models.ForEach(model =>
{
var metadata = GetModelMetadata(model, m => m.Value);
var validator = new AssertThatValidator(metadata, controllerContext, new AssertThatAttribute("Value > 0"));
var rule = validator.GetClientValidationRules().Single();
Assert.Equal("assertthat", rule.ValidationType);
});
models.ForEach(model =>
{
var metadata = GetModelMetadata(model, m => m.Value);
var validator = new RequiredIfValidator(metadata, controllerContext, new RequiredIfAttribute("Value > 0"));
var rule = validator.GetClientValidationRules().Single();
Assert.Equal("requiredif", rule.ValidationType);
});
}
