public void GetDescriptors_ReturnsCatchAllsWithEveryTagName()
        {
            // Arrange
            var divDescriptor      = new TagHelperDescriptor("div", "foo1", "SomeAssembly");
            var spanDescriptor     = new TagHelperDescriptor("span", "foo2", "SomeAssembly");
            var catchAllDescriptor = new TagHelperDescriptor(
                TagHelperDescriptorProvider.CatchAllDescriptorTarget,
                "foo3",
                "SomeAssembly");
            var descriptors = new TagHelperDescriptor[] { divDescriptor, spanDescriptor, catchAllDescriptor };
            var provider    = new TagHelperDescriptorProvider(descriptors);

            // Act
            var divDescriptors  = provider.GetDescriptors("div", attributeNames: Enumerable.Empty <string>());
            var spanDescriptors = provider.GetDescriptors("span", attributeNames: Enumerable.Empty <string>());

            // Assert
            // For divs
            Assert.Equal(2, divDescriptors.Count());
            Assert.Contains(divDescriptor, divDescriptors);
            Assert.Contains(catchAllDescriptor, divDescriptors);

            // For spans
            Assert.Equal(2, spanDescriptors.Count());
            Assert.Contains(spanDescriptor, spanDescriptors);
            Assert.Contains(catchAllDescriptor, spanDescriptors);
        }
        public void GetDescriptors_ReturnsCatchAllDescriptorsForPrefixedTags()
        {
            // Arrange
            var catchAllDescriptor = CreatePrefixedDescriptor("th:", TagHelperDescriptorProvider.ElementCatchAllTarget, "foo1");
            var descriptors        = new[] { catchAllDescriptor };
            var provider           = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv  = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty <string>());
            var retrievedDescriptorsSpan = provider.GetDescriptors("th:span", attributeNames: Enumerable.Empty <string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptorsDiv);

            Assert.Same(catchAllDescriptor, descriptor);
            descriptor = Assert.Single(retrievedDescriptorsSpan);
            Assert.Same(catchAllDescriptor, descriptor);
        }
        public void GetDescriptors_OnlyUnderstandsSinglePrefix()
        {
            // Arrange
            var divDescriptor  = CreatePrefixedDescriptor("th:", "div", "foo1");
            var spanDescriptor = CreatePrefixedDescriptor("th2:", "span", "foo2");
            var descriptors    = new[] { divDescriptor, spanDescriptor };
            var provider       = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv  = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty <string>());
            var retrievedDescriptorsSpan = provider.GetDescriptors("th2:span", attributeNames: Enumerable.Empty <string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptorsDiv);

            Assert.Same(divDescriptor, descriptor);
            Assert.Empty(retrievedDescriptorsSpan);
        }
        public void GetDescriptors_ReturnsNothingForUnprefixedTags(string tagName)
        {
            // Arrange
            var divDescriptor = CreatePrefixedDescriptor("th:", tagName, "foo1");
            var descriptors   = new[] { divDescriptor };
            var provider      = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv = provider.GetDescriptors("div", attributeNames: Enumerable.Empty <string>());

            // Assert
            Assert.Empty(retrievedDescriptorsDiv);
        }
        public void GetDescriptors_ReturnsNothingForUnregisteredTags()
        {
            // Arrange
            var divDescriptor  = new TagHelperDescriptor("div", "foo1", "SomeAssembly");
            var spanDescriptor = new TagHelperDescriptor("span", "foo2", "SomeAssembly");
            var descriptors    = new TagHelperDescriptor[] { divDescriptor, spanDescriptor };
            var provider       = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("foo", attributeNames: Enumerable.Empty <string>());

            // Assert
            Assert.Empty(retrievedDescriptors);
        }
        public void GetDescriptors_ReturnsDescriptorsWithRequiredAttributes(
            string tagName,
            IEnumerable <string> providedAttributes,
            IEnumerable <TagHelperDescriptor> availableDescriptors,
            IEnumerable <TagHelperDescriptor> expectedDescriptors)
        {
            // Arrange
            var provider = new TagHelperDescriptorProvider(availableDescriptors);

            // Act
            var resolvedDescriptors = provider.GetDescriptors(tagName, providedAttributes);

            // Assert
            Assert.Equal(expectedDescriptors, resolvedDescriptors, TagHelperDescriptorComparer.Default);
        }
        public void GetDescriptors_DuplicateDescriptorsAreNotPartOfTagHelperDescriptorPool()
        {
            // Arrange
            var divDescriptor = new TagHelperDescriptor("div", "foo1", "SomeAssembly");
            var descriptors   = new TagHelperDescriptor[] { divDescriptor, divDescriptor };
            var provider      = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("div", attributeNames: Enumerable.Empty <string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);

            Assert.Same(divDescriptor, descriptor);
        }
        public void GetDescriptors_ReturnsDescriptorsForPrefixedTags()
        {
            // Arrange
            var divDescriptor = CreatePrefixedDescriptor("th:", "div", "foo1");
            var descriptors   = new[] { divDescriptor };
            var provider      = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty <string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);

            Assert.Same(divDescriptor, descriptor);
        }
        public void GetDescriptors_ReturnsEmptyDescriptorsWithPrefixAsTagName()
        {
            // Arrange
            var catchAllDescriptor = CreatePrefixedDescriptor(
                "th",
                TagHelperDescriptorProvider.ElementCatchAllTarget,
                "foo1");
            var descriptors = new[] { catchAllDescriptor };
            var provider    = new TagHelperDescriptorProvider(descriptors);

            // Act
            var resolvedDescriptors = provider.GetDescriptors("th", attributeNames: Enumerable.Empty <string>());

            // Assert
            Assert.Empty(resolvedDescriptors);
        }
        public void GetDescriptors_DoesNotReturnNonCatchAllTagsForCatchAll()
        {
            // Arrange
            var divDescriptor      = new TagHelperDescriptor("div", "foo1", "SomeAssembly");
            var spanDescriptor     = new TagHelperDescriptor("span", "foo2", "SomeAssembly");
            var catchAllDescriptor = new TagHelperDescriptor(
                TagHelperDescriptorProvider.CatchAllDescriptorTarget,
                "foo3",
                "SomeAssembly");
            var descriptors = new TagHelperDescriptor[] { divDescriptor, spanDescriptor, catchAllDescriptor };
            var provider    = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors(TagHelperDescriptorProvider.CatchAllDescriptorTarget, attributeNames: Enumerable.Empty <string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);

            Assert.Same(catchAllDescriptor, descriptor);
        }
        public void GetDescriptors_DuplicateDescriptorsAreNotPartOfTagHelperDescriptorPool()
        {
            // Arrange
            var divDescriptor = new TagHelperDescriptor
            {
                TagName = "div",
                TypeName = "foo1",
                AssemblyName = "SomeAssembly",
            };
            var descriptors = new TagHelperDescriptor[] { divDescriptor, divDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("div", attributeNames: Enumerable.Empty<string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);
            Assert.Same(divDescriptor, descriptor);
        }
        public void GetDescriptors_ReturnsCatchAllsWithEveryTagName()
        {
            // Arrange
            var divDescriptor = new TagHelperDescriptor
            {
                TagName = "div",
                TypeName = "foo1",
                AssemblyName = "SomeAssembly",
            };
            var spanDescriptor = new TagHelperDescriptor
            {
                TagName = "span",
                TypeName = "foo2",
                AssemblyName = "SomeAssembly",
            };
            var catchAllDescriptor = new TagHelperDescriptor
            {
                TagName = TagHelperDescriptorProvider.ElementCatchAllTarget,
                TypeName = "foo3",
                AssemblyName = "SomeAssembly",
            };
            var descriptors = new TagHelperDescriptor[] { divDescriptor, spanDescriptor, catchAllDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var divDescriptors = provider.GetDescriptors("div", attributeNames: Enumerable.Empty<string>());
            var spanDescriptors = provider.GetDescriptors("span", attributeNames: Enumerable.Empty<string>());

            // Assert
            // For divs
            Assert.Equal(2, divDescriptors.Count());
            Assert.Contains(divDescriptor, divDescriptors);
            Assert.Contains(catchAllDescriptor, divDescriptors);

            // For spans
            Assert.Equal(2, spanDescriptors.Count());
            Assert.Contains(spanDescriptor, spanDescriptors);
            Assert.Contains(catchAllDescriptor, spanDescriptors);
        }
        public void GetDescriptors_ReturnsNothingForUnregisteredTags()
        {
            // Arrange
            var divDescriptor = new TagHelperDescriptor
            {
                TagName = "div",
                TypeName = "foo1",
                AssemblyName = "SomeAssembly",
            };
            var spanDescriptor = new TagHelperDescriptor
            {
                TagName = "span",
                TypeName = "foo2",
                AssemblyName = "SomeAssembly",
            };
            var descriptors = new TagHelperDescriptor[] { divDescriptor, spanDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("foo", attributeNames: Enumerable.Empty<string>());

            // Assert
            Assert.Empty(retrievedDescriptors);
        }
        public void GetDescriptors_ReturnsNothingForUnprefixedTags(string tagName)
        {
            // Arrange
            var divDescriptor = CreatePrefixedDescriptor("th:", tagName, "foo1");
            var descriptors = new[] { divDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv = provider.GetDescriptors("div", attributeNames: Enumerable.Empty<string>());

            // Assert
            Assert.Empty(retrievedDescriptorsDiv);
        }
        public void GetDescriptors_ReturnsDescriptorsForPrefixedTags()
        {
            // Arrange
            var divDescriptor = CreatePrefixedDescriptor("th:", "div", "foo1");
            var descriptors = new[] { divDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty<string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);
            Assert.Same(divDescriptor, descriptor);
        }
        public void GetDescriptors_ReturnsCatchAllDescriptorsForPrefixedTags()
        {
            // Arrange
            var catchAllDescriptor = CreatePrefixedDescriptor("th:", TagHelperDescriptorProvider.ElementCatchAllTarget, "foo1");
            var descriptors = new[] { catchAllDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty<string>());
            var retrievedDescriptorsSpan = provider.GetDescriptors("th:span", attributeNames: Enumerable.Empty<string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptorsDiv);
            Assert.Same(catchAllDescriptor, descriptor);
            descriptor = Assert.Single(retrievedDescriptorsSpan);
            Assert.Same(catchAllDescriptor, descriptor);
        }
        public void GetDescriptors_OnlyUnderstandsSinglePrefix()
        {
            // Arrange
            var divDescriptor = CreatePrefixedDescriptor("th:", "div", "foo1");
            var spanDescriptor = CreatePrefixedDescriptor("th2:", "span", "foo2");
            var descriptors = new[] { divDescriptor, spanDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptorsDiv = provider.GetDescriptors("th:div", attributeNames: Enumerable.Empty<string>());
            var retrievedDescriptorsSpan = provider.GetDescriptors("th2:span", attributeNames: Enumerable.Empty<string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptorsDiv);
            Assert.Same(divDescriptor, descriptor);
            Assert.Empty(retrievedDescriptorsSpan);
        }
        public void GetDescriptors_ReturnsEmptyDescriptorsWithPrefixAsTagName()
        {
            // Arrange
            var catchAllDescriptor = CreatePrefixedDescriptor(
                "th",
                TagHelperDescriptorProvider.ElementCatchAllTarget,
                "foo1");
            var descriptors = new[] { catchAllDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var resolvedDescriptors = provider.GetDescriptors("th", attributeNames: Enumerable.Empty<string>());

            // Assert
            Assert.Empty(resolvedDescriptors);
        }
        public void GetDescriptors_ReturnsDescriptorsWithRequiredAttributes(
            string tagName,
            IEnumerable<string> providedAttributes,
            IEnumerable<TagHelperDescriptor> availableDescriptors,
            IEnumerable<TagHelperDescriptor> expectedDescriptors)
        {
            // Arrange
            var provider = new TagHelperDescriptorProvider(availableDescriptors);

            // Act
            var resolvedDescriptors = provider.GetDescriptors(tagName, providedAttributes);

            // Assert
            Assert.Equal(expectedDescriptors, resolvedDescriptors, TagHelperDescriptorComparer.Default);
        }
        public void GetDescriptors_DoesNotReturnNonCatchAllTagsForCatchAll()
        {
            // Arrange
            var divDescriptor = new TagHelperDescriptor("div", "foo1", "SomeAssembly");
            var spanDescriptor = new TagHelperDescriptor("span", "foo2", "SomeAssembly");
            var catchAllDescriptor = new TagHelperDescriptor(
                TagHelperDescriptorProvider.ElementCatchAllTarget,
                "foo3",
                "SomeAssembly");
            var descriptors = new TagHelperDescriptor[] { divDescriptor, spanDescriptor, catchAllDescriptor };
            var provider = new TagHelperDescriptorProvider(descriptors);

            // Act
            var retrievedDescriptors = provider.GetDescriptors(TagHelperDescriptorProvider.ElementCatchAllTarget, attributeNames: Enumerable.Empty<string>());

            // Assert
            var descriptor = Assert.Single(retrievedDescriptors);
            Assert.Same(catchAllDescriptor, descriptor);
        }
        public void GetDescriptors_ReturnsDescriptorsWithRequiredAttributes(
            string tagName,
            string parentTagName,
            IEnumerable<TagHelperDescriptor> availableDescriptors,
            IEnumerable<TagHelperDescriptor> expectedDescriptors)
        {
            // Arrange
            var provider = new TagHelperDescriptorProvider(availableDescriptors);

            // Act
            var resolvedDescriptors = provider.GetDescriptors(
                tagName,
                attributeNames: Enumerable.Empty<string>(),
                parentTagName: parentTagName);

            // Assert
            Assert.Equal(expectedDescriptors, resolvedDescriptors, CaseSensitiveTagHelperDescriptorComparer.Default);
        }