public static IHtmlString BootstrapLabelFor(
this HtmlHelper helper,
string propertyName,
string colMd)
{
return(LabelHelper(helper, ModelMetadata.FromStringExpression(propertyName, helper.ViewData), ExpressionHelper.GetExpressionText(propertyName),
"col-md-" + colMd + " control-label"));
//return helper.Label(propertyName, new
//{
// @class = "col-md-3 control-label"
//});
}
public void ValidationMessageWithClientValidation_ExplicitMessage_Valid()
{
var originalProviders = ModelValidatorProviders.Providers.ToArray();
ModelValidatorProviders.Providers.Clear();
try
{
// Arrange
HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
FormContext formContext = new FormContext();
htmlHelper.ViewContext.ClientValidationEnabled = true;
htmlHelper.ViewContext.FormContext = formContext;
ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
{
new ModelClientValidationRule()
{
ValidationType = "ValidationRule1"
},
new ModelClientValidationRule()
{
ValidationType = "ValidationRule2"
}
};
Mock <ModelValidator> mockValidator = new Mock <ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
mockValidator.Setup(v => v.GetClientValidationRules())
.Returns(expectedValidationRules);
Mock <ModelValidatorProvider> mockValidatorProvider = new Mock <ModelValidatorProvider>();
mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny <ModelMetadata>(), It.IsAny <ControllerContext>()))
.Returns(new[] { mockValidator.Object });
ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);
// Act
MvcHtmlString html = htmlHelper.ValidationMessage("baz", "some explicit message"); // 'baz' is valid
// Assert
Assert.Equal(@"<span class=""field-validation-valid"" id=""baz_validationMessage"">some explicit message</span>", html.ToHtmlString());
Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
Assert.Equal("baz_validationMessage", formContext.FieldValidators["baz"].ValidationMessageId);
Assert.False(formContext.FieldValidators["baz"].ReplaceValidationMessageContents);
Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
}
finally
{
ModelValidatorProviders.Providers.Clear();
foreach (var provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public void FromStringExpressionGuardClauses()
{
// Null expression throws
Assert.ThrowsArgumentNull(
() => ModelMetadata.FromStringExpression(null, new ViewDataDictionary()),
"expression");
// Null view data dictionary throws
Assert.ThrowsArgumentNull(
() => ModelMetadata.FromStringExpression("expression", null),
"viewData");
}
public void Validate_AddsClientValidationMetadata()
{
var originalProviders = ModelValidatorProviders.Providers.ToArray();
ModelValidatorProviders.Providers.Clear();
try
{
// Arrange
HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
FormContext formContext = new FormContext()
{
FormId = "form_id"
};
htmlHelper.ViewContext.ClientValidationEnabled = true;
htmlHelper.ViewContext.FormContext = formContext;
ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
{
new ModelClientValidationRule()
{
ValidationType = "ValidationRule1"
},
new ModelClientValidationRule()
{
ValidationType = "ValidationRule2"
}
};
Mock <ModelValidator> mockValidator = new Mock <ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
mockValidator.Setup(v => v.GetClientValidationRules())
.Returns(expectedValidationRules);
Mock <ModelValidatorProvider> mockValidatorProvider = new Mock <ModelValidatorProvider>();
mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny <ModelMetadata>(), It.IsAny <ControllerContext>()))
.Returns(new[] { mockValidator.Object });
ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);
// Act
htmlHelper.Validate("baz");
// Assert
Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
}
finally
{
ModelValidatorProviders.Providers.Clear();
foreach (var provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public void TemplateHelperReturnsEmptyStringForAlreadyVisitedType() // DDB #224750
{
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));
// Act
string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */);
// Assert
Assert.AreEqual(String.Empty, result);
}
public static void ValidationMessage(
HtmlHelper htmlHelper, XcstWriter output, string modelName, string?validationMessage = null, HtmlAttribs?htmlAttributes = null,
string?tag = null)
{
if (modelName is null)
{
throw new ArgumentNullException(nameof(modelName));
}
ModelMetadata metadata = ModelMetadata.FromStringExpression(modelName, htmlHelper.ViewData);
ValidationMessageHelper(htmlHelper, output, metadata, modelName, validationMessage, htmlAttributes, tag);
}
private static void SetViewdata(IDropDownAttribute attr, string name, ViewDataDictionary viewData)
{
if (!string.IsNullOrWhiteSpace(attr.DependsOn))
{
var metaData = ModelMetadata.FromStringExpression(attr.DependsOn, viewData);
SetViewdataWithValue((DropDownAttribute)attr, name, viewData, metaData.Model);
}
else
{
var viewDataKey = "DDKey_" + name;
viewData[viewDataKey] = viewData[viewDataKey] ?? attr.GetMethodResult();
}
}
public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, string validationMessage, IDictionary <string, object> htmlAttributes)
{
if (modelName == null)
{
throw new ArgumentNullException("modelName");
}
return(ValidationMessageHelper(htmlHelper,
ModelMetadata.FromStringExpression(modelName, htmlHelper.ViewContext.ViewData),
modelName,
validationMessage,
htmlAttributes));
}
// Validate
public static void Validate(this HtmlHelper htmlHelper, string modelName)
{
if (modelName == null)
{
throw new ArgumentNullException("modelName");
}
ValidateHelper(
htmlHelper,
ModelMetadata.FromStringExpression(modelName, htmlHelper.ViewContext.ViewData),
modelName
);
}
/// <summary>
/// Recupera os atributos de validação.
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
public static IDictionary <string, object> GetUnobtrusiveValidationAttributes(this IWidget instance)
{
if (instance.ViewContext.UnobtrusiveJavaScriptEnabled && instance.ViewData.ModelMetadata != null)
{
var name = instance.Name;
var htmlHelper = new HtmlHelper(instance.ViewContext, new WidgetViewDataContainer {
ViewData = instance.ViewData
});
var metadata = instance.ModelMetadata ?? ModelMetadata.FromStringExpression(name, instance.ViewData);
return(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));
}
return(null);
}
private static IHtmlString RenderEditor(HtmlHelper html, string expression, string templateName = null, string htmlFieldName = null, object additionalViewData = null, Func <object, HelperResult> templateDelegate = null)
{
if (templateDelegate != null)
{
var metaData = ModelMetadata.FromStringExpression(expression, html.ViewData);
var helperResult = templateDelegate(metaData.Model);
return(new MvcHtmlString(helperResult.ToHtmlString()));
}
else
{
return(html.Editor(expression, templateName, htmlFieldName, additionalViewData));
}
}
public static void TextArea(
HtmlHelper htmlHelper, XcstWriter output, string name, object?value, int rows, int columns, HtmlAttribs?htmlAttributes = null)
{
ModelMetadata metadata = ModelMetadata.FromStringExpression(name, htmlHelper.ViewData);
if (value != null)
{
metadata.Model = value;
}
var rowsAndColumns = GetRowsAndColumnsDictionary(rows, columns);
TextAreaHelper(htmlHelper, output, metadata, name, rowsAndColumns, htmlAttributes);
}
public void TemplateHelperConvertsNullModelsToNullDisplayTextInReadOnlyMode()
{
// Arrange
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
metadata.NullDisplayText = "NullDisplayText";
// Act
string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */, ExecuteTemplateSpy);
// Assert
Assert.AreEqual("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = NullDisplayText, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
}
public void ValidationMessageForWithClientValidation_Unobtrusive()
{
var originalProviders = ModelValidatorProviders.Providers.ToArray();
ModelValidatorProviders.Providers.Clear();
try
{
// Arrange
HtmlHelper <ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
FormContext formContext = new FormContext();
htmlHelper.ViewContext.ClientValidationEnabled = true;
htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
htmlHelper.ViewContext.FormContext = formContext;
ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
{
new ModelClientValidationRule()
{
ValidationType = "ValidationRule1"
},
new ModelClientValidationRule()
{
ValidationType = "ValidationRule2"
}
};
Mock <ModelValidator> mockValidator = new Mock <ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
mockValidator.Setup(v => v.GetClientValidationRules())
.Returns(expectedValidationRules);
Mock <ModelValidatorProvider> mockValidatorProvider = new Mock <ModelValidatorProvider>();
mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny <ModelMetadata>(), It.IsAny <ControllerContext>()))
.Returns(new[] { mockValidator.Object });
ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);
// Act
MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.baz);
// Assert
Assert.Equal(@"<span class=""field-validation-valid"" data-valmsg-for=""baz"" data-valmsg-replace=""true""></span>", html.ToHtmlString());
}
finally
{
ModelValidatorProviders.Providers.Clear();
foreach (var provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public void TemplateHelperDoesNotApplyEditFormatStringInEditModeForNullModel()
{
// Arrange
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
metadata.EditFormatString = "{0} world!";
// Act
string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit, null /* additionalViewData */, ExecuteTemplateSpy);
// Assert
Assert.AreEqual("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
}
public void TemplateHelperAddsNullModelsTypeToVisitedObjects() // DDB #224750
{
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
ViewDataDictionary viewData = null;
// Act
TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
(_html, _viewData, _templateName, _mode, _getViews) => { viewData = _viewData; return(String.Empty); });
// Assert
Assert.IsNotNull(viewData);
Assert.IsTrue(viewData.TemplateInfo.VisitedObjects.Contains(typeof(string)));
}
public void TemplateHelperPreservesSameInstanceOfModelMetadata() // DDB #225858
{
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
ViewDataDictionary callbackViewData = null;
// Act
string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
(_html, _viewData, _templateName, _mode, _getViewNames) => { callbackViewData = _viewData; return(String.Empty); });
// Assert
Assert.IsNotNull(callbackViewData);
Assert.AreSame(metadata, callbackViewData.ModelMetadata);
}
public void TemplateHelperNonNullNonEmptyStringModel()
{
// Arrange
HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel {
MyProperty = "Hello"
});
ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
// Act
string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */, ExecuteTemplateSpy);
// Assert
Assert.AreEqual("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
}
public void FromStringExpressionValueInModelProperty()
{
// Arrange
DummyContactModel model = new DummyContactModel {
FirstName = "John"
};
ViewDataDictionary viewData = new ViewDataDictionary(model);
// Act
ModelMetadata metadata = ModelMetadata.FromStringExpression("FirstName", viewData);
// Assert
Assert.Equal("John", metadata.Model);
}
public void ValidationMessageForWithClientValidation()
{
var originalProviders = ModelValidatorProviders.Providers.ToArray();
ModelValidatorProviders.Providers.Clear();
try {
// Arrange
HtmlHelper <ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
FormContext formContext = new FormContext();
htmlHelper.ViewContext.ClientValidationEnabled = true;
htmlHelper.ViewContext.FormContext = formContext;
ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[] {
new ModelClientValidationRule()
{
ValidationType = "ValidationRule1"
},
new ModelClientValidationRule()
{
ValidationType = "ValidationRule2"
}
};
Mock <ModelValidator> mockValidator = new Mock <ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
mockValidator.Expect(v => v.GetClientValidationRules())
.Returns(expectedValidationRules);
Mock <ModelValidatorProvider> mockValidatorProvider = new Mock <ModelValidatorProvider>();
mockValidatorProvider.Expect(vp => vp.GetValidators(It.IsAny <ModelMetadata>(), It.IsAny <ControllerContext>()))
.Returns(new[] { mockValidator.Object });
ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);
// Act
MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.baz);
// Assert
Assert.AreEqual(@"<span class=""field-validation-valid"" id=""baz_validationMessage""></span>", html.ToHtmlString(),
"ValidationMessageFor() should always return something if client validation is enabled.");
Assert.IsNotNull(formContext.GetValidationMetadataForField("baz"));
Assert.AreEqual("baz_validationMessage", formContext.FieldValidators["baz"].ValidationMessageId);
CollectionAssert.AreEqual(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
}
finally {
ModelValidatorProviders.Providers.Clear();
foreach (var provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public override MvcHtmlString Render()
{
var tagBuilder = new TagBuilder("label");
tagBuilder.Attributes.Add("for", TagBuilder.CreateSanitizedId(this.htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(this.property)));
var metadata = ModelMetadata.FromStringExpression(this.property, this.htmlHelper.ViewData);
string innerText = Name ?? metadata.DisplayName ?? this.property;
tagBuilder.SetInnerText(innerText);
tagBuilder.MergeAttributes(this.attributes, true);
return(new MvcHtmlString(tagBuilder.ToString(TagRenderMode.Normal)));
}
public void TextAreaHelperDoesNotEncodeInnerHtmlPrefix()
{
// Arrange
HtmlHelper helper = MvcHelper.GetHtmlHelper();
ModelMetadata metadata = ModelMetadata.FromStringExpression("foo", helper.ViewData);
metadata.Model = "<model>";
// Act
MvcHtmlString html = TextAreaExtensions.TextAreaHelper(helper, metadata, "testEncoding", rowsAndColumns: null,
htmlAttributes: null, innerHtmlPrefix: "<prefix>");
// Assert
Assert.Equal(@"<textarea id=""testEncoding"" name=""testEncoding""><prefix><model></textarea>", html.ToHtmlString());
}
public void FromStringExpressionEmptyExpressionReturnsExistingModelMetadata()
{
// Arrange
Mock <ModelMetadataProvider> provider = new Mock <ModelMetadataProvider>();
ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);
ViewDataDictionary viewData = new ViewDataDictionary();
viewData.ModelMetadata = metadata;
// Act
ModelMetadata result = ModelMetadata.FromStringExpression(String.Empty, viewData, provider.Object);
// Assert
Assert.Same(metadata, result);
}
public BootstrapInputList <TModel, TSource, SValue, SText> RadioButtonList <TSource, SValue, SText>(
string htmlFieldName,
Expression <Func <TModel, IEnumerable <TSource> > > sourceDataExpression,
Expression <Func <TSource, SValue> > valueExpression,
Expression <Func <TSource, SText> > textExpression)
{
return(new BootstrapInputList <TModel, TSource, SValue, SText>(
Html,
htmlFieldName,
ModelMetadata.FromStringExpression(htmlFieldName, Html.ViewData),
sourceDataExpression,
valueExpression,
textExpression,
BootstrapInputType.RadioList));
}
public static MvcHtmlString LabelEx(this HtmlHelper htmlHelper, string expression, IDictionary <string, object> htmlAttributes, Action <ModelMetadata> metadataModifer)
{
IEnumerable <ILabelViewModifier> modifier;
var metadata = ModelMetadata.FromStringExpression(expression, htmlHelper.ViewData);
if (metadata != null && metadata.TryGetExtent <IEnumerable <ILabelViewModifier> >(out modifier))
{
modifier.MapLabelToHtmlAttributes(ref expression, ref htmlAttributes);
}
if (metadataModifer != null)
{
metadataModifer(metadata);
}
return(LabelHelperEx(htmlHelper, metadata, expression, htmlAttributes));
}
public BootstrapControlGroupInputList <TModel, TSource, SValue, SText> CheckBoxList <TSource, SValue, SText>(
string htmlFieldName,
Expression <Func <TModel, IEnumerable <TSource> > > sourceDataExpression,
Expression <Func <TSource, SValue> > valueExpression,
Expression <Func <TSource, SText> > textExpression)
{
return(new BootstrapControlGroupInputList <TModel, TSource, SValue, SText>(
html,
htmlFieldName,
ModelMetadata.FromStringExpression(htmlFieldName, html.ViewData),
sourceDataExpression,
valueExpression,
textExpression,
BootstrapInputType.CheckBoxList));
}
/// <summary>
/// Zeigt statischen Inhalt (der Wert im Model) mit Label an.
/// Der angezeigte Wert wird nicht gebunden!
/// </summary>
/// <param name="expression"></param>
/// <param name="placeholder">Der Wert der angezeigt wird, wenn der Wert null ist.</param>
/// <param name="label"></param>
/// <param name="formatString">Optionale Angabe zur Formatierung des Inhaltes.</param>
/// <returns></returns>
public MvcHtmlString Static <TProperty>(Expression <Func <TModel, TProperty> > expression, string label = null,
string placeholder = null, string formatString = null)
{
ModelMetadata modelMetadata = ModelMetadata.FromLambdaExpression(expression, Helper.ViewData);
if (modelMetadata.PropertyName != "DisplayName")
{
label = FormControlModel.GetLabel(modelMetadata, label);
}
else
{
string reducedExpression = expression.ToString().Replace(".DisplayName", "").Split(new[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries)[1];
ModelMetadata parentModelMetadata = ModelMetadata.FromStringExpression(reducedExpression, Helper.ViewData);
label = FormControlModel.GetLabel(parentModelMetadata, label);
}
object value;
if (modelMetadata.Model != null)
{
/*Wenn die Expression auf einen Wert ungleich NULL zeigt, zeige diesen als ToString an*/
value = modelMetadata.Model;
if (modelMetadata.ModelType.IsEnum)
{
string localizedEnumValue = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(modelMetadata.ModelType, value.ToString());
if (!string.IsNullOrWhiteSpace(localizedEnumValue))
{
value = localizedEnumValue;
}
}
if (!string.IsNullOrWhiteSpace(formatString))
{
/*Es ist ein Format für die Ausgabe angegeben => Formatieren!*/
value = string.Format(formatString, value);
}
}
else
{
/*Wenn die Expression auf einen Wert zeigt der NULL ist, wird der Platzhalter-Text verwendet.*/
value = placeholder;
}
StaticControlModel model = new StaticControlModel(Helper, label, value);
return(Helper.Partial("EditorTemplates/Forms/Static", model));
}
private TBuilder InitFieldForBuilder <TField, TBuilder>(string expression, bool setId, Func <object, object> convert = null, string format = null)
where TField : Field
where TBuilder : Field.Builder <TField, TBuilder>, new()
{
TBuilder builder = new TBuilder();
var cmp = builder.ToComponent();
cmp.ViewContext = this.HtmlHelper.ViewContext;
cmp.IDFromControlFor = setId;
cmp.ConvertControlForValue = convert;
cmp.FormatControlForValue = format;
builder.ControlFor(expression);
cmp.SetControlFor(ModelMetadata.FromStringExpression(expression, this.HtmlHelper.ViewData));
return(builder);
}
internal static MvcHtmlString Label(
this HtmlHelper html,
string expression,
string labelText,
IDictionary <string, object> htmlAttributes,
ModelMetadataProvider metadataProvider
)
{
return(LabelHelper(
html,
ModelMetadata.FromStringExpression(expression, html.ViewData, metadataProvider),
expression,
labelText,
htmlAttributes
));
}
public void FromStringExpressionWithNullModelButValidModelMetadataShouldReturnProperPropertyMetadata()
{
// Arrange
ViewDataDictionary viewData = new ViewDataDictionary();
viewData.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(DummyContactModel));
// Act
ModelMetadata result = ModelMetadata.FromStringExpression("NullableIntValue", viewData);
// Assert
Assert.Null(result.Model);
Assert.Equal(typeof(Nullable <int>), result.ModelType);
Assert.Equal("NullableIntValue", result.PropertyName);
Assert.Equal(typeof(DummyContactModel), result.ContainerType);
}
