Created WildcardExtensionsTests. Changed license to MIT.

Author: Anton Vorontsov

LICENSE.txt

@@ -175,6 +175,6 @@ All notable changes being tracked in the [changelog](./docs/changelog.md) file.
 
 ## License
 
-This library licenced under GNU General Public License v3. That means you are free to use it anywhere you want, but if you modify library by yourself you have to provide all notable changes to the community.
+This library licenced under MIT license.
 
 Feel free to contribute!

readme.md

@@ -2,13 +2,13 @@
 
 namespace RabbitMQ.Client.Core.DependencyInjection
 {
-    internal class TreeNode
+    public class TreeNode
     {
         public string KeyPartition { get; set; }
 
         public TreeNode Parent { get; set; }
 
-        public List<TreeNode> Nodes { get; set; } = new List<TreeNode>();
+        public List<TreeNode> Nodes { get; } = new List<TreeNode>();
 
         public bool IsLastNode { get; set; }
     }

src/RabbitMQ.Client.Core.DependencyInjection/TreeNode.cs

@@ -3,13 +3,13 @@
 
 namespace RabbitMQ.Client.Core.DependencyInjection
 {
-    internal static class WildcardExtensions
+    public static class WildcardExtensions
     {
         private const string Separator = ".";
         private const string SingleWordPattern = "*";
         private const string MultipleWordsPattern = "#";
 
-        internal static IEnumerable<TreeNode> ConstructTree(IEnumerable<string> routingKeyBindings)
+        public static IEnumerable<TreeNode> ConstructTree(IEnumerable<string> routingKeyBindings)
         {
             var tree = new List<TreeNode>();
 
@@ -49,7 +49,7 @@ internal static IEnumerable<TreeNode> ConstructTree(IEnumerable<string> routingK
             return tree;
         }
 
-        internal static IEnumerable<string> GetMatchingRoutingKeys(IEnumerable<TreeNode> bindingsTree, string[] routingKeyParts, int depth = 0)
+        public static IEnumerable<string> GetMatchingRoutePatterns(IEnumerable<TreeNode> bindingsTree, string[] routingKeyParts, int depth = 0)
         {
             foreach (var node in bindingsTree)
             {
@@ -65,7 +65,7 @@ internal static IEnumerable<string> GetMatchingRoutingKeys(IEnumerable<TreeNode>
                         var tails = CollectRoutingKeyTails(routingKeyParts, depth);
                         foreach (var tail in tails)
                         {
-                            var routes = GetMatchingRoutingKeys(node.Nodes, tail, depth: 0);
+                            var routes = GetMatchingRoutePatterns(node.Nodes, tail, depth: 0);
                             foreach (var route in routes)
                             {
                                 yield return route;
@@ -81,7 +81,7 @@ internal static IEnumerable<string> GetMatchingRoutingKeys(IEnumerable<TreeNode>
                     }
                     else if (routingKeyParts.Length != depth + 1 && node.Nodes.Any())
                     {
-                        var routes = GetMatchingRoutingKeys(node.Nodes, routingKeyParts, depth + 1).ToList();
+                        var routes = GetMatchingRoutePatterns(node.Nodes, routingKeyParts, depth + 1).ToList();
                         foreach (var route in routes)
                         {
                             yield return route;

src/RabbitMQ.Client.Core.DependencyInjection/WildcardExtensions.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests
+{
+    public class WildcardExtensionsTests
+    {
+        readonly string[] _routes;
+
+        public WildcardExtensionsTests()
+        {
+            _routes = new[] {
+                "#",
+                "#.delete",
+                "#.create",
+                "#.update",
+                "create.*",
+                "create.#",
+                "*.update",
+                "*.create.*",
+                "*.*.*",
+                "*.*.create",
+            };
+        }
+
+        [Fact]
+        public void ShouldProperlyConstructTree()
+        {
+            var tree = WildcardExtensions.ConstructTree(_routes);
+            
+            var countNodes = CountNodes(tree);
+            Assert.Equal(15, countNodes);
+            
+            Assert.Equal(4, tree.Count());
+            Assert.Contains(tree, x => x.IsLastNode && x.KeyPartition == "#");
+            Assert.Contains(tree, x => !x.IsLastNode && x.KeyPartition == "#");
+            Assert.Contains(tree, x => x.KeyPartition == "*");
+            Assert.Contains(tree, x => x.KeyPartition == "create");
+
+            var sharpNodes = tree.FirstOrDefault(x => !x.IsLastNode && x.KeyPartition == "#").Nodes;
+            Assert.Equal(3, sharpNodes.Count);
+            Assert.Contains(sharpNodes, x => x.KeyPartition == "delete");
+            Assert.Contains(sharpNodes, x => x.KeyPartition == "create");
+            Assert.Contains(sharpNodes, x => x.KeyPartition == "update");
+            
+            var createNodes = tree.FirstOrDefault(x => x.KeyPartition == "create").Nodes;
+            Assert.Equal(2, createNodes.Count);
+            Assert.Contains(createNodes, x => x.KeyPartition == "*");
+            Assert.Contains(createNodes, x => x.KeyPartition == "#");
+            
+            var asteriskNodes = tree.FirstOrDefault(x => x.KeyPartition == "*").Nodes;
+            Assert.Equal(3, asteriskNodes.Count);
+            Assert.Contains(asteriskNodes, x => x.KeyPartition == "*");
+            Assert.Contains(asteriskNodes, x => x.KeyPartition == "create");
+            Assert.Contains(asteriskNodes, x => x.KeyPartition == "update");
+            
+            var doubleAsteriskNodes = asteriskNodes.FirstOrDefault(x => x.KeyPartition == "*").Nodes;
+            Assert.Equal(2, doubleAsteriskNodes.Count);
+            Assert.Contains(doubleAsteriskNodes, x => x.KeyPartition == "*");
+            Assert.Contains(doubleAsteriskNodes, x => x.KeyPartition == "create");
+            
+            var asteriskCreateNodes = asteriskNodes.FirstOrDefault(x => x.KeyPartition == "create").Nodes;
+            Assert.Single(asteriskCreateNodes);
+            Assert.Contains(asteriskCreateNodes, x => x.KeyPartition == "*");
+        }
+
+        [Theory]
+        [InlineData("create.connection", new[] { "#", "create.*", "create.#" })]
+        [InlineData("create.stable.connection", new[] { "#", "create.#", "*.*.*" })]
+        [InlineData("connection.create.stable", new[] { "#", "*.create.*", "*.*.*" })]
+        [InlineData("file.delete", new[] { "#", "#.delete" })]
+        [InlineData("file.info.delete", new[] { "#", "#.delete", "*.*.*" })]
+        [InlineData("file.update", new[] { "#", "#.update", "*.update" })]
+        [InlineData("file.update.author", new[] { "#", "*.*.*" })]
+        [InlineData("file.update.author.credentials", new[] { "#" })]
+        [InlineData("report.create", new[] { "#", "#.create" })]
+        [InlineData("final.report.create", new[] { "#", "#.create", "*.*.*", "*.*.create" })]
+        public void ShouldProperlyGetMatchingRoutes(string routingKey, IEnumerable<string> routes)
+        {
+            var tree = WildcardExtensions.ConstructTree(_routes);
+
+            var routingKeyParts = routingKey.Split(".");
+            var matchingRoutes = WildcardExtensions.GetMatchingRoutePatterns(tree, routingKeyParts).ToList();
+            
+            Assert.Equal(routes.Count(), matchingRoutes.Count);
+            foreach (var route in routes)
+            {
+                Assert.Contains(matchingRoutes, x => x == route);
+            }
+        }
+
+        int CountNodes(IEnumerable<TreeNode> nodes)
+        {
+            var count = nodes.Count();
+            foreach (var node in nodes)
+            {
+                if (node.Nodes.Any())
+                {
+                    count += CountNodes(node.Nodes);
+                }
+            }
+
+            return count;
+        }
+    }
+}