private async Task <string> buildValidationMessageHtml(ModelExplorer property, TweakingConfiguration tweakingConfig)
{
PropertyTweakingConfiguration propertyConfig = tweakingConfig.GetByPropertyFullName(property.GetFullName());
TagHelper validationMessage = new ValidationMessageTagHelper(_htmlGenerator)
{
For = new ModelExpression(property.GetFullName(), property),
ViewContext = _viewContext
};
var errorClassName = propertyConfig?.ValidationClasses;
if (string.IsNullOrEmpty(errorClassName))
{
errorClassName = "text-danger";
}
return(await GetGeneratedContentFromTagHelper("span",
TagMode.StartTagAndEndTag,
validationMessage,
new TagHelperAttributeList()
{
new TagHelperAttribute("class", propertyConfig?.ValidationClasses)
}));
}
public async Task ProcessAsync_CallsIntoGenerateValidationMessageWithExpectedParameters()
{
// Arrange
var expectedViewContext = CreateViewContext();
var modelExpression = CreateModelExpression("Hello");
var generator = new Mock <IHtmlGenerator>();
generator
.Setup(mock => mock.GenerateValidationMessage(
expectedViewContext,
modelExpression.ModelExplorer,
modelExpression.Name,
null,
null,
null))
.Returns(new TagBuilder("span"))
.Verifiable();
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
For = modelExpression,
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var context = new TagHelperContext(
tagName: "span",
allAttributes: new TagHelperAttributeList(
Enumerable.Empty <TagHelperAttribute>()),
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
"span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
validationMessageTagHelper.ViewContext = expectedViewContext;
// Act & Assert
await validationMessageTagHelper.ProcessAsync(context, output);
generator.Verify();
Assert.Equal("span", output.TagName);
Assert.Empty(output.Attributes);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
}
protected virtual string GetValidationAsHtml(TagHelperContext context, TagHelperOutput output)
{
var validationMessageTagHelper = new ValidationMessageTagHelper(_generator)
{
For = TagHelper.AspFor,
ViewContext = TagHelper.ViewContext
};
var attributeList = new TagHelperAttributeList {
{ "class", "text-danger" }
};
return(RenderTagHelper(attributeList, context, validationMessageTagHelper, _encoder, "span", TagMode.StartTagAndEndTag, true));
}
protected virtual async Task <string> GetValidationAsHtmlAsync(TagHelperContext context, TagHelperOutput output, TagHelperOutput inputTag)
{
var validationMessageTagHelper = new ValidationMessageTagHelper(_generator)
{
For = TagHelper.AspFor,
ViewContext = TagHelper.ViewContext
};
var attributeList = new TagHelperAttributeList {
{ "class", "text-danger" }
};
return(await validationMessageTagHelper.RenderAsync(attributeList, context, _encoder, "span", TagMode.StartTagAndEndTag));
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var helper = new ValidationMessageTagHelper(Generator);
helper.ViewContext = ViewContext;
helper.For = For;
helper.Init(context);
await helper.ProcessAsync(context, output);
string name = For.Name.Substring(For.Name.LastIndexOf('.') + 1).ToLower();
output.Attributes.SetAttribute(":data-valmsg-for", $"`${{id}}.{ name }`");
}
private async Task <TagHelperOutput> CreateValidationMessageElement(TagHelperContext context)
{
ValidationMessageTagHelper validationMessageTagHelper =
new ValidationMessageTagHelper(Generator)
{
For = this.For,
ViewContext = this.ViewContext
};
TagHelperOutput validationMessageOutput = CreateTagHelperOutput("span");
await validationMessageTagHelper.ProcessAsync(context, validationMessageOutput);
return(validationMessageOutput);
}
protected async Task <string> RenderValidationTagHelperAsync()
{
ValidationMessageTagHelper validationMessageTagHelper = new ValidationMessageTagHelper(this.htmlGenerator);
validationMessageTagHelper.For = DataModel;
validationMessageTagHelper.ViewContext = ViewContext;
string tagString = await RenderTagHelperAsync("span",
TagMode.StartTagAndEndTag,
validationMessageTagHelper,
new TagHelperAttributeList(new[]
{
new TagHelperAttribute("class", new HtmlString("text-danger text-small"))
}));
return(tagString);
}
private async Task <TagHelperOutput> GenerateValidationMessage(TagHelperContext context)
{
var validationMessageTagHelper =
new ValidationMessageTagHelper(_htmlGenerator)
{
For = this.For,
ViewContext = this.ViewContext,
};
var inputOutput = CreateTagHelperOutput("span");
inputOutput.Attributes.Add(new TagHelperAttribute("class", _defaultValidationClass));
await validationMessageTagHelper.ProcessAsync(context, inputOutput);
return(inputOutput);
}
protected virtual string GetValidationAsHtml(TagHelperContext context, TagHelperOutput output, TagHelperOutput inputTag)
{
if (inputTag.Attributes.Any(a => a.Name.ToLowerInvariant() == "type" && a.Value.ToString().ToLowerInvariant() == "hidden"))
{
return("");
}
var validationMessageTagHelper = new ValidationMessageTagHelper(_generator)
{
For = TagHelper.AspFor,
ViewContext = TagHelper.ViewContext
};
var attributeList = new TagHelperAttributeList {
{ "class", "text-danger" }
};
return(RenderTagHelper(attributeList, context, validationMessageTagHelper, _encoder, "span", TagMode.StartTagAndEndTag, true));
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
// Get input tag
var inputTag = new InputTagHelper(_htmlGenerator)
{
For = this.For,
ViewContext = this.ViewContext
};
// Get label tag
var labelTag = new LabelTagHelper(_htmlGenerator)
{
For = this.For,
ViewContext = this.ViewContext
};
// Get validation tag
var validationTag = new ValidationMessageTagHelper(_htmlGenerator)
{
For = this.For,
ViewContext = this.ViewContext
};
output.Content.AppendHtml(await labelTag.GetGeneratedContent(_htmlEncoder, "label", TagMode.StartTagAndEndTag, new TagHelperAttributeList {
new TagHelperAttribute("class", "col-md-2 control-label")
}));
// Field and validation within the same div
output.Content.AppendHtml("<div class=\"col-md-10\">");
output.Content.AppendHtml(await inputTag.GetGeneratedContent(_htmlEncoder, "input", TagMode.StartTagAndEndTag, new TagHelperAttributeList {
new TagHelperAttribute("class", "form-control")
}));
output.Content.AppendHtml(await validationTag.GetGeneratedContent(_htmlEncoder, "span", TagMode.StartTagAndEndTag, new TagHelperAttributeList {
new TagHelperAttribute("class", "text-danger")
}));
output.Content.AppendHtml("</div>");
string classValue = "form-group";
if (output.Attributes.ContainsName("class"))
{
classValue += " " + output.Attributes["class"].Value;
}
output.Attributes.SetAttribute("class", classValue);
}
public async Task ProcessAsync_WithEmptyNameFor_Throws()
{
// Arrange
var expectedTagName = "span";
var expectedMessage = "The name of an HTML field cannot be null or empty. Instead use methods " +
"Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper.Editor or Microsoft.AspNetCore.Mvc.Rendering." +
"IHtmlHelper`1.EditorFor with a non-empty htmlFieldName argument value.";
var metadataProvider = new EmptyModelMetadataProvider();
var modelExpression = CreateModelExpression(string.Empty);
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression,
ViewContext = viewContext,
};
var tagHelperContext = new TagHelperContext(
expectedTagName,
new TagHelperAttributeList
{
{ "for", modelExpression },
},
new Dictionary <object, object>(),
"test");
var output = new TagHelperOutput(
expectedTagName,
new TagHelperAttributeList(),
(_, __) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent()));
// Act & Assert
await ExceptionAssert.ThrowsArgumentAsync(
() => validationMessageTagHelper.ProcessAsync(tagHelperContext, output),
paramName : "expression",
exceptionMessage : expectedMessage);
}
public async Task ProcessAsync_DoesNothingIfNullFor()
{
// Arrange
var generator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object);
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var output = new TagHelperOutput(
tagName: "span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) => Task.FromResult <TagHelperContent>(
new DefaultTagHelperContent()));
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
var context = new TagHelperContext(
tagName: "span",
allAttributes: new TagHelperAttributeList(
Enumerable.Empty <TagHelperAttribute>()),
items: new Dictionary <object, object>(),
uniqueId: "test");
var viewContext = CreateViewContext();
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("span", output.TagName);
Assert.Empty(output.Attributes);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
}
public async Task ProcessAsync_PassesValidationForThrough_EvenIfNullFor()
{
// Arrange
var expectedAttributeValue = "-expression-";
var expectedTagName = "span";
// Generator is not used in this scenario.
var generator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
ViewContext = CreateViewContext(),
};
var tagHelperContext = new TagHelperContext(
expectedTagName,
new TagHelperAttributeList(),
new Dictionary <object, object>(),
"test");
var output = new TagHelperOutput(
expectedTagName,
new TagHelperAttributeList
{
{ "data-valmsg-for", expectedAttributeValue },
},
(_, __) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent()));
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedTagName, output.TagName);
var attribute = Assert.Single(output.Attributes);
Assert.Equal("data-valmsg-for", attribute.Name);
Assert.Equal(expectedAttributeValue, attribute.Value);
}
public async Task ProcessAsync_CallsIntoGenerateValidationMessageWithExpectedParameters()
{
// Arrange
var expectedViewContext = CreateViewContext();
var modelExpression = CreateModelExpression("Hello");
var generator = new Mock<IHtmlGenerator>();
generator
.Setup(mock => mock.GenerateValidationMessage(
expectedViewContext,
modelExpression.ModelExplorer,
modelExpression.Name,
null,
null,
null))
.Returns(new TagBuilder("span"))
.Verifiable();
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
For = modelExpression,
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var context = new TagHelperContext(
allAttributes: new TagHelperAttributeList(
Enumerable.Empty<TagHelperAttribute>()),
items: new Dictionary<object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
"span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return Task.FromResult<TagHelperContent>(tagHelperContent);
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
validationMessageTagHelper.ViewContext = expectedViewContext;
// Act & Assert
await validationMessageTagHelper.ProcessAsync(context, output);
generator.Verify();
Assert.Equal("span", output.TagName);
Assert.Empty(output.Attributes);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
}
public async Task ProcessAsync_DoesNothingIfNullFor()
{
// Arrange
var generator = new Mock<IHtmlGenerator>(MockBehavior.Strict);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object);
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var output = new TagHelperOutput(
tagName: "span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) => Task.FromResult<TagHelperContent>(
new DefaultTagHelperContent()));
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
var context = new TagHelperContext(
allAttributes: new TagHelperAttributeList(
Enumerable.Empty<TagHelperAttribute>()),
items: new Dictionary<object, object>(),
uniqueId: "test");
var viewContext = CreateViewContext();
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("span", output.TagName);
Assert.Empty(output.Attributes);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
}
public async Task ProcessAsync_GeneratesExpectedOutput()
{
// Arrange
var expectedTagName = "not-span";
var metadataProvider = new TestModelMetadataProvider();
var modelExpression = CreateModelExpression("Name");
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var tagHelperContext = new TagHelperContext(
allAttributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" },
{ "for", modelExpression },
},
items: new Dictionary<object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagName,
attributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" }
},
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return Task.FromResult<TagHelperContent>(tagHelperContent);
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(4, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id"));
Assert.Equal("myvalidationmessage", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("class"));
Assert.Equal("field-validation-valid", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-for"));
Assert.Equal("Name", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-replace"));
Assert.Equal("true", attribute.Value);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
Assert.Equal(expectedTagName, output.TagName);
}
public async Task ProcessAsync_MergesTagBuilderFromGenerateValidationMessage(
string childContent, string expectedOutputContent)
{
// Arrange
var tagBuilder = new TagBuilder("span2");
tagBuilder.InnerHtml.SetHtmlContent("New HTML");
tagBuilder.Attributes.Add("data-foo", "bar");
tagBuilder.Attributes.Add("data-hello", "world");
var generator = new Mock<IHtmlGenerator>(MockBehavior.Strict);
var setup = generator
.Setup(mock => mock.GenerateValidationMessage(
It.IsAny<ViewContext>(),
It.IsAny<ModelExplorer>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<object>()))
.Returns(tagBuilder);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
For = CreateModelExpression("Hello")
};
var output = new TagHelperOutput(
"span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent(childContent);
return Task.FromResult<TagHelperContent>(tagHelperContent);
});
var context = new TagHelperContext(
allAttributes: new TagHelperAttributeList(
Enumerable.Empty<TagHelperAttribute>()),
items: new Dictionary<object, object>(),
uniqueId: "test");
var viewContext = CreateViewContext();
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("span", output.TagName);
Assert.Equal(2, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-foo"));
Assert.Equal("bar", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-hello"));
Assert.Equal("world", attribute.Value);
Assert.Equal(expectedOutputContent, output.Content.GetContent());
}
public async Task ProcessAsync_GeneratesExpectedOutput_WithEmptyNameFor_WithValidationFor()
{
// Arrange
var expectedAttributeValue = "-expression-";
var expectedTagName = "span";
var metadataProvider = new EmptyModelMetadataProvider();
var modelExpression = CreateModelExpression(string.Empty);
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression,
ViewContext = viewContext,
};
var tagHelperContext = new TagHelperContext(
expectedTagName,
new TagHelperAttributeList
{
{ "for", modelExpression },
},
new Dictionary <object, object>(),
"test");
var output = new TagHelperOutput(
expectedTagName,
new TagHelperAttributeList
{
{ "data-valmsg-for", expectedAttributeValue },
},
(_, __) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent()));
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedTagName, output.TagName);
Assert.Collection(output.Attributes,
attribute =>
{
Assert.Equal("data-valmsg-for", attribute.Name);
Assert.Equal(expectedAttributeValue, attribute.Value);
},
attribute =>
{
Assert.Equal("class", attribute.Name);
Assert.Equal("field-validation-valid", attribute.Value);
},
attribute =>
{
Assert.Equal("data-valmsg-replace", attribute.Name);
Assert.Equal("true", attribute.Value);
});
}
public async Task ProcessAsync_GeneratesExpectedOutput()
{
// Arrange
var expectedTagName = "not-span";
var metadataProvider = new TestModelMetadataProvider();
var modelExpression = CreateModelExpression("Name");
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var tagHelperContext = new TagHelperContext(
tagName: "not-span",
allAttributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" },
{ "for", modelExpression },
},
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagName,
attributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" }
},
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(4, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id"));
Assert.Equal("myvalidationmessage", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("class"));
Assert.Equal("field-validation-valid", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-for"));
Assert.Equal("Name", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-replace"));
Assert.Equal("true", attribute.Value);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
Assert.Equal(expectedTagName, output.TagName);
}
public async Task ProcessAsync_MergesTagBuilderFromGenerateValidationMessage(
string childContent,
string expectedMessage,
string expectedOutputContent)
{
// Arrange
var tagBuilder = new TagBuilder("span2");
tagBuilder.InnerHtml.SetHtmlContent("New HTML");
tagBuilder.Attributes.Add("data-foo", "bar");
tagBuilder.Attributes.Add("data-hello", "world");
var generator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var setup = generator
.Setup(mock => mock.GenerateValidationMessage(
It.IsAny <ViewContext>(),
It.IsAny <ModelExplorer>(),
It.IsAny <string>(),
expectedMessage,
It.IsAny <string>(),
It.IsAny <object>()))
.Returns(tagBuilder);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
For = CreateModelExpression("Hello")
};
var output = new TagHelperOutput(
"span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent(childContent);
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
var context = new TagHelperContext(
tagName: "span",
allAttributes: new TagHelperAttributeList(
Enumerable.Empty <TagHelperAttribute>()),
items: new Dictionary <object, object>(),
uniqueId: "test");
var viewContext = CreateViewContext();
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("span", output.TagName);
Assert.Equal(2, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-foo"));
Assert.Equal("bar", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-hello"));
Assert.Equal("world", attribute.Value);
Assert.Equal(expectedOutputContent, output.Content.GetContent());
}
