public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-div"; var metadataProvider = new TestModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var validationSummaryTagHelper = new ValidationSummaryTagHelper(htmlGenerator) { ValidationSummary = ValidationSummary.All, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "class", "form-control" } }); output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent("Custom Content"); Model model = null; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); validationSummaryTagHelper.ViewContext = viewContext; // Act await validationSummaryTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(2, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("class")); Assert.Equal("form-control validation-summary-valid", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-summary")); Assert.Equal("true", attribute.Value); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal("Custom Content<ul><li style=\"display:none\"></li>" + Environment.NewLine + "</ul>", output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_ThrowsIfRouteAndActionOrControllerProvided(string propertyName) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Route = "Default", }; typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home"); var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList()); var expectedErrorMessage = "Cannot determine an 'href' attribute for <a>. An <a> with a specified " + "'asp-route' must not have an 'asp-action' or 'asp-controller' attribute."; // Act & Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context: null, output: output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public async Task TagHelper_LeavesOutputUnchanged_IfForNotBound2() { // Arrange var expectedAttributes = new Dictionary <string, string> { { "class", "form-control" }, }; var expectedContent = "original content"; var expectedTagName = "label"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); var metadata = metadataProvider.GetMetadataForProperty( modelAccessor: () => null, containerType: typeof(Model), propertyName: nameof(Model.Text)); var modelExpression = new ModelExpression(nameof(Model.Text), metadata); var tagHelper = new LabelTagHelper(); var tagHelperContext = new TagHelperContext(allAttributes: new Dictionary <string, object>()); var output = new TagHelperOutput(expectedTagName, expectedAttributes, expectedContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); Model model = null; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; tagHelper.Generator = htmlGenerator; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedContent, output.Content); Assert.Equal(expectedTagName, output.TagName); }
public async Task Process_GeneratesExpectedOutput( object container, Type containerType, object model, NameAndId nameAndId, string expectedContent) { // Arrange var expectedAttributes = new Dictionary <string, object> { { "class", "form-control" }, { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedTagName = "not-textarea"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, container); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, model); // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelper = new TextAreaTagHelper { For = modelExpression, }; var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object>(), items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var htmlAttributes = new Dictionary <string, object> { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes) { SelfClosing = true, }; output.Content.SetContent("original content"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; tagHelper.Generator = htmlGenerator; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.True(output.SelfClosing); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_DoesNotUseGenerator_IfSelectedNullOrNoSelectedValues( string originalContent, string selected, string value, IEnumerable<string> selectedValues, TagHelperOutput ignored) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, }; var originalTagName = "not-option"; var contextAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, { "value", value }, }; var originalPreContent = "original pre-content"; var originalPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(originalContent); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput(originalTagName, originalAttributes) { TagMode = TagMode.StartTagAndEndTag, }; output.PreContent.SetContent(originalPreContent); output.Content.SetContent(originalContent); output.PostContent.SetContent(originalPostContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); viewContext.FormContext.FormData[SelectTagHelper.SelectedValuesFormDataKey] = selectedValues; var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act & Assert (does not throw) // Tag helper would throw an NRE if it used Generator value. await tagHelper.ProcessAsync(tagHelperContext, output); }
public async Task ProcessAsyncInTemplate_WithItems_GeneratesExpectedOutput_DoesNotChangeSelectList( object model, Type containerType, Func<object> modelAccessor, NameAndId nameAndId, string expectedOptions) { // Arrange var originalAttributes = new Dictionary<string, object> { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new Dictionary<string, object>(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent + expectedOptions; var expectedTagName = "select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(name: string.Empty, modelExplorer: modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary<string, object>(), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput(expectedTagName, originalAttributes) { SelfClosing = true }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = nameAndId.Name; var items = new SelectList(new[] { "", "outer text", "inner text", "other text" }); var savedDisabled = items.Select(item => item.Disabled).ToList(); var savedGroup = items.Select(item => item.Group).ToList(); var savedSelected = items.Select(item => item.Selected).ToList(); var savedText = items.Select(item => item.Text).ToList(); var savedValue = items.Select(item => item.Value).ToList(); var tagHelper = new SelectTagHelper { For = modelExpression, Generator = htmlGenerator, Items = items, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.True(output.SelfClosing); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); Assert.NotNull(viewContext.FormContext?.FormData); Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); Assert.Equal(savedGroup, items.Select(item => item.Group)); Assert.Equal(savedSelected, items.Select(item => item.Selected)); Assert.Equal(savedText, items.Select(item => item.Text)); Assert.Equal(savedValue, items.Select(item => item.Value)); }
public async Task Process_GeneratesExpectedOutput( object container, Type containerType, object model, NameAndId nameAndId, string expectedContent) { // Arrange var expectedAttributes = new TagHelperAttributeList { { "class", "form-control" }, { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedTagName = "not-textarea"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, container); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, model); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelper = new TextAreaTagHelper(htmlGenerator) { For = modelExpression, }; var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var htmlAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes) { TagMode = TagMode.SelfClosing, }; output.Content.SetContent("original content"); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedContent, HtmlContentUtilities.HtmlContentToString(output.Content)); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput( object container, Type containerType, object model, NameAndId nameAndId, string expectedValue) { // Arrange var expectedAttributes = new TagHelperAttributeList { { "class", "form-control" }, { "type", "text" }, { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, { "value", expectedValue }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = "original post-content"; var expectedTagName = "not-input"; var context = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var originalAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, originalAttributes) { TagMode = TagMode.StartTagOnly, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(expectedPostContent); var htmlGenerator = new TestableHtmlGenerator(new EmptyModelMetadataProvider()) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var tagHelper = GetTagHelper( htmlGenerator, container, containerType, model, propertyName: nameof(Model.Text), expressionName: nameAndId.Name); // Act await tagHelper.ProcessAsync(context, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(TagMode.StartTagOnly, output.TagMode); Assert.Equal(expectedTagName, output.TagName); }
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", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "id", "myvalidationmessage" } }); 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_GeneratesExpectedOutput( object model, Type containerType, Func<object> modelAccessor, NameAndId nameAndId, string ignored) { // Arrange var originalAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new TagHelperAttributeList(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent; var expectedTagName = "not-select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }) { TagMode = TagMode.SelfClosing, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var tagHelper = new SelectTagHelper(htmlGenerator) { For = modelExpression, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-a"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object> { { "id", "myanchor" }, { "asp-route-foo", "bar" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "asp-fragment", "hello=world" }, { "asp-host", "contoso.com" }, { "asp-protocol", "http" } }, uniqueId: "test", getChildContentAsync: () => Task.FromResult("Something Else")); var output = new TagHelperOutput( expectedTagName, attributes: new Dictionary <string, string> { { "id", "myanchor" }, { "asp-route-foo", "bar" }, }) { Content = "Something" }; var urlHelper = new Mock <IUrlHelper>(); urlHelper .Setup(mock => mock.Action( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <object>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var anchorTagHelper = new AnchorTagHelper { Action = "index", Controller = "home", Fragment = "hello=world", Generator = htmlGenerator, Host = "contoso.com", Protocol = "http", }; // Act await anchorTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(2, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("id")); Assert.Equal("myanchor", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("href")); Assert.Equal("home/index", attribute.Value); Assert.Equal("Something", output.Content); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_CallsGeneratorWithExpectedValues_ItemsAndAttribute( IEnumerable <SelectListItem> inputItems, string attributeName, string attributeValue, IEnumerable <SelectListItem> expectedItems) { // Arrange var contextAttributes = new TagHelperAttributeList { // Provided for completeness. Select tag helper does not confirm AllAttributes set is consistent. { attributeName, attributeValue }, }; var originalAttributes = new TagHelperAttributeList { { attributeName, attributeValue }, }; var propertyName = "Property1"; var expectedTagName = "select"; var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var metadataProvider = new EmptyModelMetadataProvider(); string model = null; var modelExplorer = metadataProvider.GetModelExplorerForType(typeof(string), model); var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator.Object, metadataProvider); // Simulate a (model => model) scenario. E.g. the calling helper may appear in a low-level template. var modelExpression = new ModelExpression(string.Empty, modelExplorer); viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = propertyName; var currentValues = new string[0]; htmlGenerator .Setup(real => real.GetCurrentValues( viewContext, modelExplorer, string.Empty, // expression false)) // allowMultiple .Returns(currentValues) .Verifiable(); htmlGenerator .Setup(real => real.GenerateSelect( viewContext, modelExplorer, null, // optionLabel string.Empty, // expression expectedItems, currentValues, false, // allowMultiple null)) // htmlAttributes .Returns((TagBuilder)null) .Verifiable(); var tagHelper = new SelectTagHelper(htmlGenerator.Object) { For = modelExpression, Items = inputItems, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert htmlGenerator.Verify(); var keyValuePair = Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); Assert.Same(currentValues, keyValuePair.Value); }
public async Task ProcessAsyncInTemplate_WithItems_GeneratesExpectedOutput_DoesNotChangeSelectList( object model, Type containerType, Func <object> modelAccessor, NameAndId nameAndId, string expectedOptions) { // Arrange var originalAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new TagHelperAttributeList(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent + expectedOptions; var expectedTagName = "select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(name: string.Empty, modelExplorer: modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList <IReadOnlyTagHelperAttribute>( Enumerable.Empty <IReadOnlyTagHelperAttribute>()), items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.AppendHtml("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }) { TagMode = TagMode.SelfClosing, }; output.PreContent.AppendHtml(expectedPreContent); output.Content.AppendHtml(expectedContent); output.PostContent.AppendHtml(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = nameAndId.Name; var items = new SelectList(new[] { "", "outer text", "inner text", "other text" }); var savedDisabled = items.Select(item => item.Disabled).ToList(); var savedGroup = items.Select(item => item.Group).ToList(); var savedSelected = items.Select(item => item.Selected).ToList(); var savedText = items.Select(item => item.Text).ToList(); var savedValue = items.Select(item => item.Value).ToList(); var tagHelper = new SelectTagHelper(htmlGenerator) { For = modelExpression, Items = items, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, HtmlContentUtilities.HtmlContentToString(output.PostContent)); Assert.Equal(expectedTagName, output.TagName); Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); Assert.Equal(savedGroup, items.Select(item => item.Group)); Assert.Equal(savedSelected, items.Select(item => item.Selected)); Assert.Equal(savedText, items.Select(item => item.Text)); Assert.Equal(savedValue, items.Select(item => item.Value)); }
public async Task ProcessAsync_GeneratesExpectedOutput( object model, Type containerType, Func <object> modelAccessor, NameAndId nameAndId, string ignored) { // Arrange var originalAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new TagHelperAttributeList(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent; var expectedTagName = "not-select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList <IReadOnlyTagHelperAttribute>( Enumerable.Empty <IReadOnlyTagHelperAttribute>()), items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }) { TagMode = TagMode.SelfClosing, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var tagHelper = new SelectTagHelper(htmlGenerator) { For = modelExpression, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); }
public async Task ProcessAsync_ThrowsIfRouteAndActionOrControllerProvided(string propertyName) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Route = "Default", }; typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home"); var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList()); var expectedErrorMessage = "Cannot determine an 'href' attribute for <a>. An <a> with a specified " + "'asp-route' must not have an 'asp-action' or 'asp-controller' attribute."; // Act & Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context: null, output: output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public async Task ProcessAsync_CallsGeneratorWithExpectedValues_ItemsAndMultiple( IEnumerable <SelectListItem> inputItems, string multiple, IEnumerable <SelectListItem> expectedItems, bool expectedAllowMultiple) { // Arrange var contextAttributes = new Dictionary <string, object> { // Attribute will be restored if value matches "multiple". { "multiple", multiple }, }; var originalAttributes = new Dictionary <string, string>(); var propertyName = "Property1"; var expectedTagName = "select"; var tagHelperContext = new TagHelperContext( contextAttributes, uniqueId: "test", getChildContentAsync: () => Task.FromResult("Something")); var output = new TagHelperOutput(expectedTagName, originalAttributes); var metadataProvider = new EmptyModelMetadataProvider(); string model = null; var metadata = metadataProvider.GetMetadataForType(() => model, typeof(string)); var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator.Object, metadataProvider); // Simulate a (model => model) scenario. E.g. the calling helper may appear in a low-level template. var modelExpression = new ModelExpression(string.Empty, metadata); viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = propertyName; ICollection <string> selectedValues = new string[0]; htmlGenerator .Setup(real => real.GenerateSelect( viewContext, metadata, null, // optionLabel string.Empty, // name expectedItems, expectedAllowMultiple, null, // htmlAttributes out selectedValues)) .Returns((TagBuilder)null) .Verifiable(); var tagHelper = new SelectTagHelper { For = modelExpression, Items = inputItems, Generator = htmlGenerator.Object, Multiple = multiple, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert htmlGenerator.Verify(); Assert.NotNull(viewContext.FormContext?.FormData); var keyValuePair = Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); Assert.Same(selectedValues, keyValuePair.Value); }
public async Task ProcessAsync_WithItems_GeneratesExpectedOutput_DoesNotChangeSelectList( object model, Type containerType, Func<object> modelAccessor, NameAndId nameAndId, string expectedOptions) { // Arrange var originalAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new TagHelperAttributeList(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent + expectedOptions; var expectedTagName = "select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.AppendHtml("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }) { TagMode = TagMode.SelfClosing, }; output.PreContent.AppendHtml(expectedPreContent); output.Content.AppendHtml(expectedContent); output.PostContent.AppendHtml(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var items = new SelectList(new[] { "", "outer text", "inner text", "other text" }); var savedDisabled = items.Select(item => item.Disabled).ToList(); var savedGroup = items.Select(item => item.Group).ToList(); var savedSelected = items.Select(item => item.Selected).ToList(); var savedText = items.Select(item => item.Text).ToList(); var savedValue = items.Select(item => item.Value).ToList(); var tagHelper = new SelectTagHelper(htmlGenerator) { For = modelExpression, Items = items, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, HtmlContentUtilities.HtmlContentToString(output.PostContent)); Assert.Equal(expectedTagName, output.TagName); Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); Assert.Equal(savedGroup, items.Select(item => item.Group)); Assert.Equal(savedSelected, items.Select(item => item.Selected)); Assert.Equal(savedText, items.Select(item => item.Text)); Assert.Equal(savedValue, items.Select(item => item.Value)); }
public async Task ProcessAsync_GeneratesExpectedOutput( object model, Type containerType, Func <object> modelAccessor, string propertyPath, TagHelperOutputContent tagHelperOutputContent) { // Arrange var expectedTagName = "not-label"; var expectedAttributes = new Dictionary <string, object> { { "class", "form-control" }, { "for", tagHelperOutputContent.ExpectedId } }; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(propertyPath, modelExplorer); var tagHelper = new LabelTagHelper { For = modelExpression, }; var expectedPreContent = "original pre-content"; var expectedPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object>(), items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(tagHelperOutputContent.OriginalChildContent); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var htmlAttributes = new Dictionary <string, object> { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes); output.PreContent.SetContent(expectedPreContent); output.PostContent.SetContent(expectedPostContent); // LabelTagHelper checks IsContentModified so we don't want to forcibly set it if // tagHelperOutputContent.OriginalContent is going to be null or empty. if (!string.IsNullOrEmpty(tagHelperOutputContent.OriginalContent)) { output.Content.SetContent(tagHelperOutputContent.OriginalContent); } var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; tagHelper.Generator = htmlGenerator; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(tagHelperOutputContent.ExpectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.False(output.SelfClosing); Assert.Equal(expectedTagName, output.TagName); }
public async Task TagHelper_CallsGeneratorWithExpectedValues_RealModelType( Type modelType, object model, bool allowMultiple) { // Arrange var contextAttributes = new ReadOnlyTagHelperAttributeList <IReadOnlyTagHelperAttribute>( Enumerable.Empty <IReadOnlyTagHelperAttribute>()); var originalAttributes = new TagHelperAttributeList(); var propertyName = "Property1"; var tagName = "select"; var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( tagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var metadataProvider = new EmptyModelMetadataProvider(); var modelExplorer = metadataProvider.GetModelExplorerForType(modelType, model); var modelExpression = new ModelExpression(propertyName, modelExplorer); var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator.Object, metadataProvider); var currentValues = new string[0]; htmlGenerator .Setup(real => real.GetCurrentValues( viewContext, modelExplorer, propertyName, // expression allowMultiple)) .Returns(currentValues) .Verifiable(); htmlGenerator .Setup(real => real.GenerateSelect( viewContext, modelExplorer, null, // optionLabel propertyName, // expression It.IsAny <IEnumerable <SelectListItem> >(), currentValues, allowMultiple, null)) // htmlAttributes .Returns((TagBuilder)null) .Verifiable(); var tagHelper = new SelectTagHelper(htmlGenerator.Object) { For = modelExpression, ViewContext = viewContext, }; // Act tagHelper.Init(tagHelperContext); await tagHelper.ProcessAsync(tagHelperContext, output); // Assert htmlGenerator.Verify(); var keyValuePair = Assert.Single( tagHelperContext.Items, entry => (Type)entry.Key == typeof(SelectTagHelper)); Assert.Same(currentValues, keyValuePair.Value); }
public async Task ProcessAsync_GeneratesExpectedOutput( object model, Type containerType, Func <object> modelAccessor, string propertyPath, TagHelperOutputContent tagHelperOutputContent) { // Arrange var expectedTagName = "not-label"; var expectedAttributes = new Dictionary <string, string> { { "class", "form-control" }, { "for", tagHelperOutputContent.ExpectedId } }; var metadataProvider = new DataAnnotationsModelMetadataProvider(); // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text"); var modelExpression = new ModelExpression(propertyPath, metadata); var tagHelper = new LabelTagHelper { For = modelExpression, }; var expectedPreContent = "original pre-content"; var expectedPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object>(), uniqueId: "test", getChildContentAsync: () => Task.FromResult(tagHelperOutputContent.OriginalChildContent)); var htmlAttributes = new Dictionary <string, string> { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes) { PreContent = expectedPreContent, PostContent = expectedPostContent, }; // LabelTagHelper checks ContentSet so we don't want to forcibly set it if // tagHelperOutputContent.OriginalContent is going to be null or empty. if (!string.IsNullOrEmpty(tagHelperOutputContent.OriginalContent)) { output.Content = tagHelperOutputContent.OriginalContent; } var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; tagHelper.Generator = htmlGenerator; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent); Assert.Equal(tagHelperOutputContent.ExpectedContent, output.Content); Assert.Equal(expectedPostContent, output.PostContent); Assert.False(output.SelfClosing); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput( string originalContent, string selected, string value, IEnumerable<string> selectedValues, TagHelperOutput expectedTagHelperOutput) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, }; if (selected != null) { originalAttributes.Add("selected", selected); } var contextAttributes = new TagHelperAttributeList(originalAttributes); if (value != null) { contextAttributes.Add("value", value); } var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: () => { // GetChildContentAsync should not be invoked since we are setting the content below. Assert.True(false); return Task.FromResult<TagHelperContent>(null); }); var output = new TagHelperOutput(expectedTagHelperOutput.TagName, originalAttributes) { SelfClosing = false, }; output.Content.SetContent(originalContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); viewContext.FormContext.FormData[SelectTagHelper.SelectedValuesFormDataKey] = selectedValues; var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedTagHelperOutput.TagName, output.TagName); Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent()); Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count); foreach (var attribute in output.Attributes) { Assert.Contains(attribute, expectedTagHelperOutput.Attributes); } }
public async Task ProcessAsync_GeneratesExpectedOutput_WithItems( object model, Type containerType, Func <object> modelAccessor, NameAndId nameAndId, string expectedOptions) { // Arrange var originalAttributes = new Dictionary <string, string> { { "class", "form-control" }, }; var originalContent = "original content"; var expectedAttributes = new Dictionary <string, string>(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedContent = originalContent + expectedOptions; var expectedTagName = "select"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text"); var modelExpression = new ModelExpression(nameAndId.Name, metadata); var tagHelperContext = new TagHelperContext(new Dictionary <string, object>()); var output = new TagHelperOutput(expectedTagName, originalAttributes, originalContent) { SelfClosing = true, }; var items = new SelectList(new[] { "", "outer text", "inner text", "other text" }); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var tagHelper = new SelectTagHelper { For = modelExpression, Generator = htmlGenerator, Items = items, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedContent, output.Content); Assert.False(output.SelfClosing); Assert.Equal(expectedTagName, output.TagName); Assert.NotNull(viewContext.FormContext?.FormData); var keyValuePair = Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); Assert.NotNull(keyValuePair.Value); var selectedValues = Assert.IsAssignableFrom <ICollection <string> >(keyValuePair.Value); Assert.InRange(selectedValues.Count, 0, 1); }
public void ValidationSummaryProperty_ThrowsWhenSetToInvalidValidationSummaryValue( ValidationSummary validationSummary) { // Arrange var generator = new TestableHtmlGenerator(new EmptyModelMetadataProvider()); var validationSummaryTagHelper = new ValidationSummaryTagHelper(generator); var expectedMessage = string.Format( @"The value of argument 'value' ({0}) is invalid for Enum type 'Microsoft.AspNet.Mvc.ValidationSummary'. Parameter name: value", validationSummary); // Act & Assert var ex = Assert.Throws<ArgumentException>( "value", () => { validationSummaryTagHelper.ValidationSummary = validationSummary; }); Assert.Equal(expectedMessage, ex.Message); }
public async Task ProcessAsync_CallsGeneratorWithExpectedValues_ItemsAndMultiple( IEnumerable <SelectListItem> inputItems, string multiple, IEnumerable <SelectListItem> expectedItems, bool expectedAllowMultiple) { // Arrange var contextAttributes = new Dictionary <string, object> { // Attribute will be restored if value matches "multiple". { "multiple", multiple }, }; var originalAttributes = new Dictionary <string, string>(); var content = "original content"; var propertyName = "Property1"; var expectedTagName = "select"; var tagHelperContext = new TagHelperContext(contextAttributes); var output = new TagHelperOutput(expectedTagName, originalAttributes, content); // TODO: https://github.com/aspnet/Mvc/issues/1253 // In real (model => model) scenario, ModelExpression should have name "" and // TemplateInfo.HtmlFieldPrefix should be "Property1" but empty ModelExpression name is not currently // supported, see also #1408. var metadataProvider = new EmptyModelMetadataProvider(); string model = null; var metadata = metadataProvider.GetMetadataForType(() => model, typeof(string)); var modelExpression = new ModelExpression(propertyName, metadata); var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict); var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator.Object, metadataProvider); ICollection <string> selectedValues = new string[0]; htmlGenerator .Setup(real => real.GenerateSelect( viewContext, metadata, null, // optionLabel propertyName, // name expectedItems, expectedAllowMultiple, null, // htmlAttributes out selectedValues)) .Returns((TagBuilder)null) .Verifiable(); var tagHelper = new SelectTagHelper { For = modelExpression, Items = inputItems, Generator = htmlGenerator.Object, Multiple = multiple, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert htmlGenerator.Verify(); Assert.NotNull(viewContext.FormContext?.FormData); var keyValuePair = Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); Assert.Same(selectedValues, keyValuePair.Value); }
public async Task ProcessAsync_DoesNotUseGenerator_IfSelectedNullOrNoSelectedValues( string originalContent, string selected, string value, IEnumerable <string> selectedValues, TagHelperOutput ignored) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, }; var originalTagName = "not-option"; var contextAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, { "value", value }, }; var originalPreContent = "original pre-content"; var originalPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( originalTagName, originalAttributes, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(originalContent); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }) { TagMode = TagMode.StartTagAndEndTag, }; output.PreContent.SetContent(originalPreContent); output.Content.SetContent(originalContent); output.PostContent.SetContent(originalPostContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); tagHelperContext.Items[typeof(SelectTagHelper)] = selectedValues; var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act & Assert (does not throw) // Tag helper would throw an NRE if it used Generator value. await tagHelper.ProcessAsync(tagHelperContext, output); }
public async Task Process_GeneratesExpectedOutput( object model, Type containerType, Func <object> modelAccessor, NameAndId nameAndId, string expectedContent) { // Arrange var expectedAttributes = new Dictionary <string, string> { { "class", "form-control" }, { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedTagName = "not-textarea"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text"); var modelExpression = new ModelExpression(nameAndId.Name, metadata); var tagHelper = new TextAreaTagHelper { For = modelExpression, }; var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object>(), uniqueId: "test", getChildContentAsync: () => Task.FromResult("Something")); var htmlAttributes = new Dictionary <string, string> { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes) { Content = "original content", SelfClosing = true, }; var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; tagHelper.Generator = htmlGenerator; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedContent, output.Content); Assert.False(output.SelfClosing); Assert.Equal(expectedTagName, output.TagName); }
public async Task CheckBoxHandlesMultipleAttributesSameNameCorrectly( TagHelperAttributeList outputAttributes, string expectedAttributeString) { // Arrange var originalContent = "original content"; var originalTagName = "not-input"; var expectedContent = $"{originalContent}<input {expectedAttributeString} id=\"HtmlEncode[[IsACar]]\" " + "name=\"HtmlEncode[[IsACar]]\" type=\"HtmlEncode[[checkbox]]\" value=\"HtmlEncode[[true]]\" />" + "<input name=\"HtmlEncode[[IsACar]]\" type=\"HtmlEncode[[hidden]]\" value=\"HtmlEncode[[false]]\" />"; var context = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => Task.FromResult<TagHelperContent>(result: null)); var output = new TagHelperOutput(originalTagName, outputAttributes) { TagMode = TagMode.SelfClosing, }; output.Content.SetContent(originalContent); var htmlGenerator = new TestableHtmlGenerator(new EmptyModelMetadataProvider()); var tagHelper = GetTagHelper(htmlGenerator, model: false, propertyName: nameof(Model.IsACar)); // Act await tagHelper.ProcessAsync(context, output); // Assert Assert.Empty(output.Attributes); // Moved to Content and cleared Assert.Equal(expectedContent, HtmlContentUtilities.HtmlContentToString(output.Content)); Assert.Equal(TagMode.SelfClosing, output.TagMode); Assert.Null(output.TagName); // Cleared }
public async Task ProcessAsync_GeneratesExpectedOutput( object model, Type containerType, Func<object> modelAccessor, string propertyPath, TagHelperOutputContent tagHelperOutputContent) { // Arrange var expectedTagName = "not-label"; var expectedAttributes = new TagHelperAttributeList { { "class", "form-control" }, { "for", tagHelperOutputContent.ExpectedId } }; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var modelExpression = new ModelExpression(propertyPath, modelExplorer); var tagHelper = new LabelTagHelper(htmlGenerator) { For = modelExpression, }; var expectedPreContent = "original pre-content"; var expectedPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(tagHelperOutputContent.OriginalChildContent); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var htmlAttributes = new TagHelperAttributeList { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, htmlAttributes); output.PreContent.SetContent(expectedPreContent); output.PostContent.SetContent(expectedPostContent); // LabelTagHelper checks IsContentModified so we don't want to forcibly set it if // tagHelperOutputContent.OriginalContent is going to be null or empty. if (!string.IsNullOrEmpty(tagHelperOutputContent.OriginalContent)) { output.Content.SetContent(tagHelperOutputContent.OriginalContent); } var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); tagHelper.ViewContext = viewContext; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal( tagHelperOutputContent.ExpectedContent, HtmlContentUtilities.HtmlContentToString(output.Content)); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(TagMode.StartTagAndEndTag, output.TagMode); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput( object model, Type containerType, Func<object> modelAccessor, NameAndId nameAndId, string ignored) { // Arrange var originalAttributes = new Dictionary<string, object> { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new Dictionary<string, object>(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent; var expectedTagName = "not-select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary<string, object>(), items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput(expectedTagName, originalAttributes) { SelfClosing = true, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var tagHelper = new SelectTagHelper { For = modelExpression, Generator = htmlGenerator, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.True(output.SelfClosing); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); Assert.NotNull(viewContext.FormContext?.FormData); Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-form"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object> { { "id", "myform" }, { "asp-route-foo", "bar" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "method", "post" }, { "asp-anti-forgery", true } }); var output = new TagHelperOutput( expectedTagName, attributes: new Dictionary <string, string> { { "id", "myform" }, { "asp-route-foo", "bar" }, }, content: "Something"); var urlHelper = new Mock <IUrlHelper>(); urlHelper .Setup(mock => mock.Action(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <object>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var expectedContent = "Something" + htmlGenerator.GenerateAntiForgery(viewContext) .ToString(TagRenderMode.SelfClosing); var formTagHelper = new FormTagHelper { Action = "index", AntiForgery = true, Controller = "home", Generator = htmlGenerator, Method = "post", ViewContext = viewContext, }; // Act await formTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(3, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("id")); Assert.Equal("myform", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("method")); Assert.Equal("post", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("action")); Assert.Equal("home/index", attribute.Value); Assert.Equal(expectedContent, output.Content); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-form"; var metadataProvider = new TestModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new TagHelperAttributeList { { "id", "myform" }, { "asp-route-name", "value" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "method", "post" }, { "asp-antiforgery", true } }, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "id", "myform" }, }, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something Else"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); output.PostContent.SetContent("Something"); var urlHelper = new Mock <IUrlHelper>(); urlHelper .Setup(mock => mock.Action(It.IsAny <UrlActionContext>())).Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var expectedPostContent = "Something" + HtmlContentUtilities.HtmlContentToString( htmlGenerator.GenerateAntiforgery(viewContext), new NullTestEncoder()); var formTagHelper = new FormTagHelper(htmlGenerator) { Action = "index", Antiforgery = true, Controller = "home", ViewContext = viewContext, RouteValues = { { "name", "value" }, }, }; // Act await formTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(3, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id")); Assert.Equal("myform", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("method")); Assert.Equal("post", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("action")); Assert.Equal("home/index", attribute.Value); Assert.Empty(output.PreContent.GetContent()); Assert.True(output.Content.IsEmpty); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput( string originalContent, string selected, string value, IEnumerable <string> selectedValues, TagHelperOutput expectedTagHelperOutput) { // Arrange var originalAttributes = new Dictionary <string, object> { { "label", "my-label" }, }; if (selected != null) { originalAttributes.Add("selected", selected); } var contextAttributes = new Dictionary <string, object>(originalAttributes); if (value != null) { contextAttributes.Add("value", value); } var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(originalContent); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var output = new TagHelperOutput(expectedTagHelperOutput.TagName, originalAttributes) { SelfClosing = false, }; output.Content.SetContent(originalContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); viewContext.FormContext.FormData[SelectTagHelper.SelectedValuesFormDataKey] = selectedValues; var tagHelper = new OptionTagHelper { Generator = htmlGenerator, Value = value, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedTagHelperOutput.TagName, output.TagName); Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent()); Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count); foreach (var attribute in output.Attributes) { Assert.Contains(attribute, expectedTagHelperOutput.Attributes); } }
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", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "id", "myvalidationmessage" } }); 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_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-a"; var metadataProvider = new TestModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new TagHelperAttributeList { { "id", "myanchor" }, { "asp-route-name", "value" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "asp-fragment", "hello=world" }, { "asp-host", "contoso.com" }, { "asp-protocol", "http" } }, items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something Else"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "id", "myanchor" }, }); output.Content.SetContent("Something"); var urlHelper = new Mock <IUrlHelper>(); urlHelper .Setup(mock => mock.Action(It.IsAny <UrlActionContext>())).Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Action = "index", Controller = "home", Fragment = "hello=world", Host = "contoso.com", Protocol = "http", RouteValues = { { "name", "value" }, }, }; // Act await anchorTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(2, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id")); Assert.Equal("myanchor", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("href")); Assert.Equal("home/index", attribute.Value); Assert.Equal("Something", output.Content.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-form"; var metadataProvider = new TestModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new TagHelperAttributeList { { "id", "myform" }, { "asp-route-name", "value" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "method", "post" }, { "asp-antiforgery", true } }, items: new Dictionary<object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagName, attributes: new TagHelperAttributeList { { "id", "myform" }, }, getChildContentAsync: useCachedResult => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something Else"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); output.PostContent.SetContent("Something"); var urlHelper = new Mock<IUrlHelper>(); urlHelper .Setup(mock => mock.Action(It.IsAny<UrlActionContext>())).Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var expectedPostContent = "Something" + HtmlContentUtilities.HtmlContentToString( htmlGenerator.GenerateAntiforgery(viewContext), HtmlEncoder.Default); var formTagHelper = new FormTagHelper(htmlGenerator) { Action = "index", Antiforgery = true, Controller = "home", ViewContext = viewContext, RouteValues = { { "name", "value" }, }, }; // Act await formTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(3, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id")); Assert.Equal("myform", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("method")); Assert.Equal("post", attribute.Value); attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("action")); Assert.Equal("home/index", attribute.Value); Assert.Empty(output.PreContent.GetContent()); Assert.True(output.Content.IsEmpty); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_ThrowsIfHrefConflictsWithBoundAttributes(string propertyName) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator); var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList { { "href", "http://www.contoso.com" } }, getChildContentAsync: _ => Task.FromResult<TagHelperContent>(null)); if (propertyName == "asp-route-") { anchorTagHelper.RouteValues.Add("name", "value"); } else { typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home"); } var expectedErrorMessage = "Cannot override the 'href' attribute for <a>. An <a> with a specified " + "'href' must not have attributes starting with 'asp-route-' or an " + "'asp-action', 'asp-controller', 'asp-route', 'asp-protocol', 'asp-host', or " + "'asp-fragment' attribute."; var context = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test"); // Act & Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context, output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public async Task ProcessAsync_GeneratesExpectedOutput( object container, Type containerType, object model, NameAndId nameAndId, string expectedValue) { // Arrange var expectedAttributes = new Dictionary <string, object> { { "class", "form-control" }, { "type", "text" }, { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, { "value", expectedValue }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = "original post-content"; var expectedTagName = "not-input"; var context = new TagHelperContext( allAttributes: new Dictionary <string, object>(), items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var originalAttributes = new Dictionary <string, object> { { "class", "form-control" }, }; var output = new TagHelperOutput(expectedTagName, originalAttributes) { SelfClosing = false, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(expectedPostContent); var htmlGenerator = new TestableHtmlGenerator(new EmptyModelMetadataProvider()) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; // Property name is either nameof(Model.Text) or nameof(NestedModel.Text). var tagHelper = GetTagHelper( htmlGenerator, container, containerType, model, propertyName: nameof(Model.Text), expressionName: nameAndId.Name); // Act await tagHelper.ProcessAsync(context, output); // Assert Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.False(output.SelfClosing); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_ThrowsIfRouteAndActionOrControllerProvided(string propertyName) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Route = "Default", }; typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home"); var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList(), getChildContentAsync: _ => Task.FromResult<TagHelperContent>(null)); var expectedErrorMessage = "Cannot determine an 'href' attribute for <a>. An <a> with a specified " + "'asp-route' must not have an 'asp-action' or 'asp-controller' attribute."; var context = new TagHelperContext( allAttributes: new ReadOnlyTagHelperAttributeList<IReadOnlyTagHelperAttribute>( Enumerable.Empty<IReadOnlyTagHelperAttribute>()), items: new Dictionary<object, object>(), uniqueId: "test"); // Act & Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context, output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public void ValidationSummaryProperty_ThrowsWhenSetToInvalidValidationSummaryValue( ValidationSummary validationSummary) { // Arrange var generator = new TestableHtmlGenerator(new EmptyModelMetadataProvider()); var validationSummaryTagHelper = new ValidationSummaryTagHelper(generator); var validationTypeName = typeof(ValidationSummary).FullName; var expectedMessage = $@"The value of argument 'value' ({validationSummary}) is invalid for Enum type '{validationTypeName}'. Parameter name: value"; // Act & Assert var ex = Assert.Throws<ArgumentException>( "value", () => { validationSummaryTagHelper.ValidationSummary = validationSummary; }); Assert.Equal(expectedMessage, ex.Message); }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-span"; var metadataProvider = new DataAnnotationsModelMetadataProvider(); var modelExpression = CreateModelExpression("Name"); var validationMessageTagHelper = new ValidationMessageTagHelper { For = modelExpression }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object> { { "id", "myvalidationmessage" }, { "for", modelExpression }, }, uniqueId: "test", getChildContentAsync: () => Task.FromResult("Something")); var output = new TagHelperOutput( expectedTagName, attributes: new Dictionary <string, string> { { "id", "myvalidationmessage" } }) { PreContent = expectedPreContent, Content = expectedContent, PostContent = expectedPostContent, }; var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); validationMessageTagHelper.ViewContext = viewContext; validationMessageTagHelper.Generator = htmlGenerator; // Act await validationMessageTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(4, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("id")); Assert.Equal("myvalidationmessage", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("class")); Assert.Equal("field-validation-valid", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("data-valmsg-for")); Assert.Equal("Name", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("data-valmsg-replace")); Assert.Equal("true", attribute.Value); Assert.Equal(expectedPreContent, output.PreContent); Assert.Equal(expectedContent, output.Content); Assert.Equal(expectedPostContent, output.PostContent); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_GeneratesExpectedOutput( string originalContent, string selected, string value, IEnumerable <string> selectedValues, TagHelperOutput expectedTagHelperOutput) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, }; if (selected != null) { originalAttributes.Add("selected", selected); } var contextAttributes = new TagHelperAttributeList(originalAttributes); if (value != null) { contextAttributes.Add("value", value); } var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: useCachedResult => { // GetChildContentAsync should not be invoked since we are setting the content below. Assert.True(false); return(Task.FromResult <TagHelperContent>(null)); }); var output = new TagHelperOutput(expectedTagHelperOutput.TagName, originalAttributes) { TagMode = TagMode.StartTagAndEndTag }; output.Content.SetContent(originalContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); viewContext.FormContext.FormData[SelectTagHelper.SelectedValuesFormDataKey] = selectedValues; var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedTagHelperOutput.TagName, output.TagName); Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent()); Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count); foreach (var attribute in output.Attributes) { Assert.Contains(attribute, expectedTagHelperOutput.Attributes); } }
public async Task ProcessAsync_GeneratesExpectedOutput() { // Arrange var expectedTagName = "not-a"; var metadataProvider = new TestModelMetadataProvider(); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary<string, object> { { "id", "myanchor" }, { "asp-route-foo", "bar" }, { "asp-action", "index" }, { "asp-controller", "home" }, { "asp-fragment", "hello=world" }, { "asp-host", "contoso.com" }, { "asp-protocol", "http" } }, items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something Else"); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput( expectedTagName, attributes: new Dictionary<string, object> { { "id", "myanchor" }, { "asp-route-foo", "bar" }, }); output.Content.SetContent("Something"); var urlHelper = new Mock<IUrlHelper>(); urlHelper .Setup(mock => mock.Action(It.IsAny<UrlActionContext>())).Returns("home/index"); var htmlGenerator = new TestableHtmlGenerator(metadataProvider, urlHelper.Object); var viewContext = TestableHtmlGenerator.GetViewContext(model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); var anchorTagHelper = new AnchorTagHelper { Action = "index", Controller = "home", Fragment = "hello=world", Generator = htmlGenerator, Host = "contoso.com", Protocol = "http", }; // Act await anchorTagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(2, output.Attributes.Count); var attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("id")); Assert.Equal("myanchor", attribute.Value); attribute = Assert.Single(output.Attributes, kvp => kvp.Key.Equals("href")); Assert.Equal("home/index", attribute.Value); Assert.Equal("Something", output.Content.GetContent()); Assert.Equal(expectedTagName, output.TagName); }
public async Task ProcessAsync_DoesNotUseViewContext_IfSelectedNotNull( string originalContent, string selected, string value, IEnumerable<string> ignoredValues, TagHelperOutput ignoredOutput) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, }; var originalTagName = "not-option"; var contextAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, { "value", value }, }; var originalPreContent = "original pre-content"; var originalPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( contextAttributes, items: new Dictionary<object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(originalContent); return Task.FromResult<TagHelperContent>(tagHelperContent); }); var output = new TagHelperOutput(originalTagName, originalAttributes) { SelfClosing = false, }; output.PreContent.SetContent(originalPreContent); output.Content.SetContent(originalContent); output.PostContent.SetContent(originalPostContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, }; // Act & Assert (does not throw) // Tag helper would throw an NRE if it used ViewContext or Generator values. await tagHelper.ProcessAsync(tagHelperContext, output); }
public async Task ProcessAsync_WithItems_GeneratesExpectedOutput_DoesNotChangeSelectList( object model, Type containerType, Func <object> modelAccessor, NameAndId nameAndId, string expectedOptions) { // Arrange var originalAttributes = new Dictionary <string, object> { { "class", "form-control" }, }; var originalPostContent = "original content"; var expectedAttributes = new Dictionary <string, object>(originalAttributes) { { "id", nameAndId.Id }, { "name", nameAndId.Name }, { "valid", "from validation attributes" }, }; var expectedPreContent = "original pre-content"; var expectedContent = "original content"; var expectedPostContent = originalPostContent + expectedOptions; var expectedTagName = "select"; var metadataProvider = new TestModelMetadataProvider(); var containerMetadata = metadataProvider.GetMetadataForType(containerType); var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, model); var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, "Text"); var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, modelAccessor()); var modelExpression = new ModelExpression(nameAndId.Name, modelExplorer); var tagHelperContext = new TagHelperContext( allAttributes: new Dictionary <string, object>(), items: new Dictionary <object, object>(), uniqueId: "test", getChildContentAsync: () => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent("Something"); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }); var output = new TagHelperOutput(expectedTagName, originalAttributes) { SelfClosing = true, }; output.PreContent.SetContent(expectedPreContent); output.Content.SetContent(expectedContent); output.PostContent.SetContent(originalPostContent); var htmlGenerator = new TestableHtmlGenerator(metadataProvider) { ValidationAttributes = { { "valid", "from validation attributes" }, } }; var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider); var items = new SelectList(new[] { "", "outer text", "inner text", "other text" }); var savedDisabled = items.Select(item => item.Disabled).ToList(); var savedGroup = items.Select(item => item.Group).ToList(); var savedSelected = items.Select(item => item.Selected).ToList(); var savedText = items.Select(item => item.Text).ToList(); var savedValue = items.Select(item => item.Value).ToList(); var tagHelper = new SelectTagHelper { For = modelExpression, Generator = htmlGenerator, Items = items, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.True(output.SelfClosing); Assert.Equal(expectedAttributes, output.Attributes); Assert.Equal(expectedPreContent, output.PreContent.GetContent()); Assert.Equal(expectedContent, output.Content.GetContent()); Assert.Equal(expectedPostContent, output.PostContent.GetContent()); Assert.Equal(expectedTagName, output.TagName); Assert.NotNull(viewContext.FormContext?.FormData); Assert.Single( viewContext.FormContext.FormData, entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey); Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); Assert.Equal(savedGroup, items.Select(item => item.Group)); Assert.Equal(savedSelected, items.Select(item => item.Selected)); Assert.Equal(savedText, items.Select(item => item.Text)); Assert.Equal(savedValue, items.Select(item => item.Value)); }