public static void Validate_DoesNotThrow(DataType dataType)
{
if (dataType != DataType.Custom)
{
DataTypeAttribute attribute = new DataTypeAttribute(dataType);
attribute.Validate(new object(), s_testValidationContext);
}
}
public static void GetDataTypeName_ReturnsExpectedName(DataType dataType)
{
if (dataType != DataType.Custom)
{
DataTypeAttribute attribute = new DataTypeAttribute(dataType);
Assert.Equal(Enum.GetName(typeof(DataType), dataType), attribute.GetDataTypeName());
}
}
private static IDataTypeFacet Create(DataTypeAttribute attribute, ISpecification holder) {
if (attribute == null) {
return null;
}
return attribute.DataType == DataType.Custom ? new DataTypeFacetAnnotation(attribute.CustomDataType, holder) :
new DataTypeFacetAnnotation(attribute.DataType, holder);
}
public static void GetDataTypeName_and_IsValid_on_empty_custom_DataTypeAttribute_throws_exception()
{
var attribute = new DataTypeAttribute(string.Empty);
Assert.Equal(DataType.Custom, attribute.DataType); // Only throw when call GetDataTypeName() or Validate()
AssertEx.Empty(attribute.CustomDataType); // Only throw when call GetDataTypeName() or Validate()
Assert.Throws<InvalidOperationException>(() => attribute.GetDataTypeName());
Assert.Throws<InvalidOperationException>(() => attribute.Validate(new object(), s_testValidationContext));
}
public static void Ctor_DataType(DataType dataType)
{
DataTypeAttribute attribute = new DataTypeAttribute(dataType);
Assert.Equal(dataType, attribute.DataType);
Assert.Null(attribute.CustomDataType);
bool expectedNull = dataType != DataType.Date && dataType != DataType.Time && dataType != DataType.Currency;
Assert.Equal(expectedNull, attribute.DisplayFormat == null);
}
public DataTypeAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataTypeAttribute attribute, string ruleName)
: base(metadata, context, attribute)
{
if (String.IsNullOrEmpty(ruleName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "ruleName");
}
RuleName = ruleName;
}
public DataTypeAttributeAdapter(DataTypeAttribute attribute,
[NotNull] string ruleName)
: base(attribute)
{
if (string.IsNullOrEmpty(ruleName))
{
throw new ArgumentException(Resources.ArgumentCannotBeNullOrEmpty, "ruleName");
}
RuleName = ruleName;
}
private static IDateOnlyFacet Create(DataTypeAttribute attribute, ConcurrencyCheckAttribute concurrencyCheckAttribute, ISpecification holder) {
if (attribute?.DataType == DataType.Date) {
return new DateOnlyFacet(holder);
}
if (concurrencyCheckAttribute != null) {
return null;
}
return attribute?.DataType == DataType.DateTime ? null : new DateOnlyFacet(holder);
}
public static void GetDataTypeName_and_Validate_successful_for_all_non_custom_DataTypes()
{
foreach (var enumValue in Enum.GetValues(typeof(DataType)))
{
var dataType = (DataType)enumValue;
if (DataType.Custom != dataType)
{
var attribute = new DataTypeAttribute(dataType);
Assert.Equal(Enum.GetName(typeof(DataType), enumValue), attribute.GetDataTypeName());
AssertEx.DoesNotThrow(() => attribute.Validate(new object(), s_testValidationContext));
}
}
}
public static void DataType_and_CustomDataType_assigned_correctly_for_all_non_custom_DataTypes()
{
foreach (var enumValue in Enum.GetValues(typeof(DataType)))
{
var dataType = (DataType)enumValue;
if (DataType.Custom != dataType)
{
var attribute = new DataTypeAttribute(dataType);
Assert.Equal(dataType, attribute.DataType);
Assert.Null(attribute.CustomDataType);
}
}
}
public TypePropertyValidationRuleMetadata(DataTypeAttribute attribute)
: this((ValidationAttribute) attribute)
{
switch (attribute.DataType) {
case DataType.EmailAddress:
Name = "email";
break;
case DataType.Url:
default:
Name = "url";
break;
}
Value1 = true;
_type = "boolean";
}
public static void Ctor_String(string customDataType)
{
DataTypeAttribute attribute = new DataTypeAttribute(customDataType);
Assert.Equal(DataType.Custom, attribute.DataType);
Assert.Equal(customDataType, attribute.CustomDataType);
if (string.IsNullOrEmpty(customDataType))
{
Assert.Throws<InvalidOperationException>(() => attribute.GetDataTypeName());
Assert.Throws<InvalidOperationException>(() => attribute.Validate(new object(), s_testValidationContext));
}
else
{
Assert.Equal(customDataType, attribute.GetDataTypeName());
attribute.Validate(new object(), s_testValidationContext);
}
}
public static void DisplayFormat_set_correctly_for_date_time_and_currency()
{
var dateAttribute = new DataTypeAttribute(DataType.Date);
Assert.NotNull(dateAttribute.DisplayFormat);
Assert.Equal("{0:d}", dateAttribute.DisplayFormat.DataFormatString);
Assert.True(dateAttribute.DisplayFormat.ApplyFormatInEditMode);
var timeAttribute = new DataTypeAttribute(DataType.Time);
Assert.NotNull(timeAttribute.DisplayFormat);
Assert.Equal("{0:t}", timeAttribute.DisplayFormat.DataFormatString);
Assert.True(timeAttribute.DisplayFormat.ApplyFormatInEditMode);
var currencyAttribute = new DataTypeAttribute(DataType.Currency);
Assert.NotNull(currencyAttribute.DisplayFormat);
Assert.Equal("{0:C}", currencyAttribute.DisplayFormat.DataFormatString);
Assert.False(currencyAttribute.DisplayFormat.ApplyFormatInEditMode);
}
public void GetDisplayMetadata_FindsDisplayFormat_FromDataType()
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var dataType = new DataTypeAttribute(DataType.Currency);
var displayFormat = dataType.DisplayFormat; // Non-null for DataType.Currency.
var attributes = new[] { dataType, };
var key = ModelMetadataIdentity.ForType(typeof(string));
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(attributes));
// Act
provider.GetDisplayMetadata(context);
// Assert
Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString);
}
private static void SetFromDataTypeAndDisplayAttributes(DataAnnotationsModelMetadata result,
DataTypeAttribute dataTypeAttribute, DisplayFormatAttribute displayFormatAttribute)
{
if (dataTypeAttribute != null)
{
result.DataTypeName = dataTypeAttribute.ToDataTypeName();
}
if (displayFormatAttribute == null && dataTypeAttribute != null)
{
displayFormatAttribute = dataTypeAttribute.DisplayFormat;
// If DisplayFormat value was non-null and this [DataType] is of a subclass, assume the [DataType]
// constructor used the protected DisplayFormat setter to override its default. Note deriving from
// [DataType] but preserving DataFormatString and ApplyFormatInEditMode results in
// HasNonDefaultEditFormat==true.
if (displayFormatAttribute != null && dataTypeAttribute.GetType() != typeof(DataTypeAttribute))
{
result.HasNonDefaultEditFormat = true;
}
}
else if (displayFormatAttribute != null)
{
result.HasNonDefaultEditFormat = true;
}
if (displayFormatAttribute != null)
{
result.NullDisplayText = displayFormatAttribute.NullDisplayText;
result.DisplayFormatString = displayFormatAttribute.DataFormatString;
result.ConvertEmptyStringToNull = displayFormatAttribute.ConvertEmptyStringToNull;
result.HtmlEncode = displayFormatAttribute.HtmlEncode;
if (displayFormatAttribute.ApplyFormatInEditMode)
{
result.EditFormatString = displayFormatAttribute.DataFormatString;
}
if (!displayFormatAttribute.HtmlEncode && String.IsNullOrWhiteSpace(result.DataTypeName))
{
result.DataTypeName = DataTypeUtil.HtmlTypeName;
}
// Regardless of HasNonDefaultEditFormat calculation above, treat missing EditFormatString as the
// default. Note the corner case of a [DataType] subclass overriding a non-empty default to apply a
// [DisplayFormat] lacking DataFormatString or with ApplyFormatInEditMode==false results in
// HasNonDefaultEditFormat==false.
if (String.IsNullOrEmpty(result.EditFormatString))
{
result.HasNonDefaultEditFormat = false;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocalizedDataTypeAttributeAdapter"/> class.
/// </summary>
/// <param name="metadata">The model metadata.</param>
/// <param name="context">The controller context.</param>
/// <param name="attribute">The <see cref="DataTypeAttribute"/> attribute.</param>
/// <param name="ruleName">The name of the client validation rule.</param>
public LocalizedDataTypeAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataTypeAttribute attribute, string ruleName) : base(metadata, context, attribute)
{
mRuleName = ruleName;
}
public static void GetDataTypeName_InvalidDataType_ThrowsIndexOutOfRangeException(DataType dataType)
{
DataTypeAttribute attribute = new DataTypeAttribute(dataType);
Assert.Throws<IndexOutOfRangeException>(() => attribute.GetDataTypeName());
}
private ValidationAttribute CopyAttribute(ValidationAttribute attribute)
{
ValidationAttribute result = null;
if (attribute is RangeAttribute)
{
var attr = (RangeAttribute)attribute;
result = (attr.Minimum is double)
? new RangeAttribute((double)attr.Minimum, (double)attr.Maximum)
: new RangeAttribute((int)attr.Minimum, (int)attr.Maximum);
}
if (attribute is RegularExpressionAttribute)
{
var attr = (RegularExpressionAttribute)attribute;
result = new RegularExpressionAttribute(attr.Pattern);
}
if (attribute is RequiredAttribute)
result = new RequiredAttribute();
if (attribute is StringLengthAttribute)
{
var attr = (StringLengthAttribute)attribute;
result = new StringLengthAttribute(attr.MaximumLength)
{
MinimumLength = attr.MinimumLength
};
}
if (attribute is DA.CompareAttribute)
{
var attr = (DA.CompareAttribute)attribute;
result = new DA.CompareAttribute(attr.OtherProperty);
}
if (attribute is DataTypeAttribute)
{
var attr = (DataTypeAttribute)attribute;
result = new DataTypeAttribute(attr.DataType);
}
if (result == null && attribute.GetType().GetInterfaces().Contains(typeof(ICloneable)))
result = ((ICloneable)attribute).Clone() as ValidationAttribute;
return result;
}
public void DataTypeName_AttributesHaveExpectedPrecedence()
{
// Arrange
var expected = "MultilineText";
var dataType = new DataTypeAttribute(DataType.MultilineText);
var displayFormat = new DisplayFormatAttribute { HtmlEncode = false, };
var provider = CreateProvider(new object[] { dataType, displayFormat });
var metadata = provider.GetMetadataForType(typeof(string));
// Act
var result = metadata.DataTypeName;
// Assert
Assert.Equal(expected, result);
}
public static void DataType_and_CustomDataType_assigned_correctly_for_custom_DataType()
{
var attribute = new DataTypeAttribute("CustomValue");
Assert.Equal(DataType.Custom, attribute.DataType);
Assert.Equal("CustomValue", attribute.CustomDataType);
}
private static IPasswordFacet Create(DataTypeAttribute attribute, IFacetHolder holder) {
return attribute != null && attribute.DataType == DataType.Password ? new PasswordFacetAnnotation(holder) : null;
}
public void GetDisplayMetadata_FindsDisplayFormat_OverridingDataType()
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var dataType = new DataTypeAttribute(DataType.Time); // Has a non-null DisplayFormat.
var displayFormat = new DisplayFormatAttribute() // But these values override the values from DataType
{
DataFormatString = "Cool {0}",
};
var attributes = new Attribute[] { dataType, displayFormat, };
var key = ModelMetadataIdentity.ForType(typeof(string));
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(attributes));
// Act
provider.GetDisplayMetadata(context);
// Assert
Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString);
}
public static void DisplayFormat_null_for_non_date_time_and_currency()
{
foreach (var enumValue in Enum.GetValues(typeof(DataType)))
{
var dataType = (DataType)enumValue;
if (DataType.Date != dataType
&& DataType.Time != dataType
&& DataType.Currency != dataType)
{
var attribute = new DataTypeAttribute(dataType);
Assert.Null(attribute.DisplayFormat);
}
}
}
//: this(attribute)
/// <summary>
/// Initializes a new instance of the <see cref="TypePropertyValidationRuleMetadata" /> class.
/// </summary>
/// <param name="attribute">The attribute.</param>
public TypePropertyValidationRuleMetadata(DataTypeAttribute attribute)
{
switch (attribute.DataType)
{
case DataType.EmailAddress:
this.Name = "email";
break;
case DataType.Url:
this.Name = "url";
break;
}
this.Value1 = true;
this.type = "boolean";
}
public static void DisplayFormat_ReturnsExpected(DataType dataType, string dataFormatString, bool applyFormatInEditMode)
{
DataTypeAttribute attribute = new DataTypeAttribute(dataType);
Assert.Equal(dataFormatString, attribute.DisplayFormat.DataFormatString);
Assert.Equal(applyFormatInEditMode, attribute.DisplayFormat.ApplyFormatInEditMode);
}
public void EditFormatString_AttributesHaveExpectedPrecedence()
{
// Arrange
var expected = "custom format";
var dataType = new DataTypeAttribute(DataType.Currency);
var displayFormat = new DisplayFormatAttribute
{
ApplyFormatInEditMode = true,
DataFormatString = expected,
};
var provider = CreateProvider(new object[] { displayFormat, dataType, });
var metadata = provider.GetMetadataForType(typeof(string));
// Act
var result = metadata.EditFormatString;
// Assert
Assert.Equal(expected, result);
}
public static void GetDataTypeName_and_IsValid_on_non_null_custom_DataTypeAttribute_is_successful()
{
var attribute = new DataTypeAttribute("TestCustomDataType");
Assert.Equal("TestCustomDataType", attribute.GetDataTypeName());
AssertEx.DoesNotThrow(() => attribute.Validate(new object(), s_testValidationContext));
}