rax-radix-tree 1.0.1

package/test/00.path.test.js

@@ -0,0 +1,84 @@
+const assert = require('assert');
+const { parsePath } = require('../radix-tree');
+
+describe('parsePath', function() {
+  it('should handle path without asterisk', function() {
+    const result = parsePath('/api/users');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/users',
+      path: '/api/users',
+      matchType: 'equals',
+      pathPattern: undefined
+    });
+  });
+
+  it('should handle path with a single asterisk', function() {
+    const result = parsePath('/api/users/*');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/users/',
+      path: '/api/users/*',
+      matchType: 'prefix',
+      pathPattern: '^\\/api\\/users\\/[^/]*$'
+    });
+  });
+
+  it('should handle path with two consecutive asterisks', function() {
+    const result = parsePath('/api/**');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/',
+      path: '/api/**',
+      matchType: 'prefix',
+      pathPattern: '^\\/api\\/.*$'
+    });
+  });
+
+  it('should handle complex path with multiple asterisks', function() {
+    const result = parsePath('/api/*/users/**/profile');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/',
+      path: '/api/*/users/**/profile',
+      matchType: 'prefix',
+      pathPattern: '^\\/api\\/[^/]*\\/users\\/.*\\/profile$'
+    });
+  });
+
+  it('should handle path starting with asterisk', function() {
+    const result = parsePath('**.jpg');
+    assert.deepStrictEqual(result, {
+      treePath: 'gpj.',
+      path: '**.jpg',
+      matchType: 'suffix',
+      pathPattern: '^gpj\\..*$'
+    });
+  });
+
+  it('should handle path with special characters', function() {
+    const result = parsePath('/api/users?id=*');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/users?id=',
+      path: '/api/users?id=*',
+      matchType: 'prefix',
+      pathPattern: '^\\/api\\/users\\?id=[^/]*$'
+    });
+  });
+
+  it('should handle path with more special characters', function() {
+    const result = parsePath('/api/users+/[profile].{json}');
+    assert.deepStrictEqual(result, {
+      treePath: '/api/users+/[profile].{json}',
+      path: '/api/users+/[profile].{json}',
+      matchType: 'equals',
+      pathPattern: undefined,
+    });
+  });
+
+  it('should handle empty path', function() {
+    const result = parsePath('');
+    assert.deepStrictEqual(result, {
+      treePath: '',
+      path: '',
+      matchType: 'equals',
+      pathPattern: undefined
+    });
+  });
+});

package/test/10.tree.test.js

@@ -0,0 +1,217 @@
+const assert = require('assert');
+const { RadixTree } = require('../index');
+
+describe('RadixTree', function() {
+  describe('Construction and Initialization', function() {
+    it('should correctly initialize RadixTree', function() {
+      const routes = [
+        { paths: ['/api/users'], methods: ['GET'], meta: { id: 1 } },
+        { paths: ['/api/users/*'], methods: ['POST'], meta: { id: 2 } },
+      ];
+      const tree = new RadixTree(routes);
+      assert(tree instanceof RadixTree);
+    });
+  });
+
+  describe('Route Matching', function() {
+    let tree;
+
+    beforeEach(function() {
+      const routes = [
+        { paths: ['/api/users'], meta: { id: 1 } },
+        { paths: ['/api/users'], meta: { id: 2 } },
+        { paths: ['/api/users/*'], meta: { id: 3 } },
+        { paths: ['/api/posts/**'], meta: { id: 4 } },
+        { paths: ['/api/comments'], meta: { id: 5 } },
+        { paths: ['/service/**', '/servicev2/**'], meta: { id: 6 } },
+        { paths: ['/service/user/*'], meta: { id: 7 } },
+        { paths: ['**.jpg', '*.png'], meta: { id: 8 } },
+        { paths: ['**/test.jpg'], meta: { id: 9 } },
+        { paths: ['/static/**'], meta: { id: 10 } },
+      ];
+      tree = new RadixTree(routes, null);
+    });
+
+    it('should match exact paths', function() {
+      const result = tree.findAllRoutes('/api/users');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [1, 2]);
+    });
+
+    it('should match paths with a single asterisk', function() {
+      const result = tree.findAllRoutes('/api/users/123');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 3);
+    });
+
+    it('should match normal paths with double asterisks', function() {
+        const result = tree.findAllRoutes('/api/posts/2023');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].meta.id, 4);
+    });
+
+    it('should match suffix .jpg file in nested directories', function() {
+      const result = tree.findAllRoutes('/2023/05/01.jpg');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 8);
+    });
+
+    it('should match suffix .png file in root directory', function() {
+      const result = tree.findAllRoutes('01.png');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 8);
+    });
+
+    it('should test high priority suffix matching functionality', function() {
+        const result = tree.findAllRoutes('/static/img/test.jpg');
+        assert.strictEqual(result.length, 3);
+        assert.deepStrictEqual(result.map(r => r.meta.id), [9, 8, 10]);
+    });
+
+    it('should match paths with double asterisks', function() {
+      const result = tree.findAllRoutes('/api/posts/2023/05/01');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 4);
+    });
+
+    it('should not match non-existent paths', function() {
+      const result = tree.findAllRoutes('/api/nonexistent');
+      assert.strictEqual(result.length, 0);
+    });
+
+    it('should correctly handle prefix matching', function() {
+      const result = tree.findAllRoutes('/api/users/profile');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 3);
+    });
+
+    it('should match normal paths with service/**', function() {
+      const result = tree.findAllRoutes('/service/user/123');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [7, 6]);
+    });
+
+    it('should match normal paths with servicev2/**', function() {
+      const result = tree.findAllRoutes('/servicev2/user/123');
+      assert.strictEqual(result.length, 1);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [6]);
+    });
+
+  });
+
+  describe('Adding Any Route Configuration', function() {
+    let tree;
+    beforeEach(function() {
+      const routes = [
+        { paths: ['/**'], meta: { id: 10 } },
+        { paths: ['/api/users/*/posts'], meta: { id: 11 } },
+        { paths: ['/api/users/**/comments'], meta: { id: 12 } },
+      ];
+      tree = new RadixTree(routes, null);
+    });
+    it('should match any path', function() {
+        const result = tree.findAllRoutes('/users/123/posts');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].meta.id, 10);
+      });
+      it('should match any path 2', function() {
+        const result = tree.findAllRoutes('/index');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].meta.id, 10);
+      });
+      it('should match any path 3', function() {
+        const result = tree.findAllRoutes('/');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].meta.id, 10);
+    });
+  });
+
+  describe('Method Matching', function() {
+    let tree;
+    beforeEach(function() {
+      const routes = [
+        { paths: ['/api/**'], meta: { id: 1 } },
+        { methods: ['POST'], paths: ['/**'], meta: { id: 2 } },
+        { methods: ['ALL'], paths: ['/api/users'], meta: { id: 5 } },
+        { methods: ['POST'], paths: ['/api/users'], meta: { id: 6} },
+        { methods: ['GET'], paths: ['/api/users'], meta: { id: 7} },
+        { methods: ['GET', 'POST'], paths: ['/api/users/**'], meta: { id: 8} },
+      ];
+      tree = new RadixTree(routes, null);
+    });
+
+    it('should match routes without specified method (treated as ALL)', function() {
+      const result = tree.findAllRoutes('/api/posts', 'GET');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 1);
+    });
+
+    it('should match routes with specified method', function() {
+      const result = tree.findAllRoutes('/api/users', 'POST');
+      assert.strictEqual(result.length, 4);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [6, 5, 1, 2]);
+      // assert.deepStrictEqual(result.map(r => r.meta.id).sort(), [5, 6, 8]);
+    });
+
+    it('should match routes with ALL method', function() {
+      const result = tree.findAllRoutes('/api/users', 'PUT');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [5, 1]);
+    });
+
+    it('should match multiple matching routes', function() {
+      const result = tree.findAllRoutes('/api/users/123', 'GET');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [8, 1]);
+    });
+
+    it('should not match routes with non-matching method', function() {
+      const result = tree.findAllRoutes('/api/users', 'DELETE');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [5, 1]);
+    });
+
+    it('should match global POST route', function() {
+      const result = tree.findAllRoutes('/random/path', 'POST');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 2);
+    });
+  });
+
+  describe('Complex Route Matching', function() {
+    let tree;
+
+    beforeEach(function() {
+      const routes = [
+        { paths: ['/api/items'], meta: { id: 1 } },
+        { paths: ['/api/items/*'], meta: { id: 2 } },
+        { paths: ['/api/items/**'], meta: { id: 3 } },
+
+        { paths: ['/api/users/**'], meta: { id: 10 } },
+        { paths: ['/api/users/*/posts'], meta: { id: 11 } },
+        { paths: ['/api/users/**/comments'], meta: { id: 12 } },
+      ];
+      tree = new RadixTree(routes, null);
+    });
+
+    it('should correctly distinguish between single asterisk and double asterisk matching', function() {
+      let result = tree.findAllRoutes('/api/items/123');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id).sort(), [2, 3]);
+
+      result = tree.findAllRoutes('/api/items/123/456');
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].meta.id, 3);
+    });
+
+    it('should correctly handle complex route patterns', function() {
+      let result = tree.findAllRoutes('/api/users/123/posts');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [11, 10]);
+
+      result = tree.findAllRoutes('/api/users/123/profile/comments');
+      assert.strictEqual(result.length, 2);
+      assert.deepStrictEqual(result.map(r => r.meta.id), [12, 10]);
+    });
+  });
+});

package/test/20.http-tree.test.js

@@ -0,0 +1,316 @@
+const assert = require('assert');
+const { HttpRadixTree } = require('../http-radix-tree');
+
+describe('HttpRadixTree', function () {
+
+    describe('Http Route Matching By Host', function () {
+        let tree;
+
+        beforeEach(function () {
+            const routes = [
+                { paths: ['/api/**'], meta: { id: 1 }, hosts: ['test.com'] },
+                { paths: ['/api/users/**'], meta: { id: 3 }, hosts: ['a.com', 'b.com'] },
+                { paths: ['/api/users/**'], meta: { id: 4 }, hosts: ['*.c.com'] },
+                { paths: ['/api/users/**'], meta: { id: 10 }, remoteAddrs: ['127.0.0.1', '192.168.1.3'] },
+                { paths: ['/api/users/**'], meta: { id: 11 }, remoteAddrs: ['192.168.1.1/24'] },
+                { paths: ['/api/users/**'], meta: { id: 12 }, remoteAddrs: ['192.168.1.1/16'] },
+                { paths: ['/api/users/**'], meta: { id: 20 }, exprs: ['age >= 10 and x_id mod 20 == 0'] },
+                { paths: ['/api/users/**'], meta: { id: 21 }, exprs: ['name in ("tom", "lily")'] },
+            ];
+            tree = new HttpRadixTree(routes);
+        });
+
+        it('path not found', function () {
+            const result = tree.findRoute({
+                path: '/notfound',
+                method: 'GET',
+                headers: {
+                    host: 'a.com',
+                },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('path matched, but host not matched', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                headers: {
+                    host: 'x.com',
+                },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('path matched, host matched with a.com', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                headers: {
+                    host: 'a.com',
+                },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 3);
+        });
+
+        it('path matched, host matched with b.com', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                headers: {
+                    host: 'b.com',
+                },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 3);
+        });
+
+        it('path matched, host matched with c.com', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                headers: {
+                    host: 'c.com',
+                },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 4);
+        });
+
+        it('path matched, host matched with www.c.com', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                headers: {
+                    host: 'www.c.com',
+                },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 4);
+        });
+
+        it('path matched, remoteAddr matched with 127.0.0.1', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                remoteAddr: '127.0.0.1',
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 10);
+        });
+
+        it('path matched, remoteAddr matched with 192.168.1.3', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                remoteAddr: '192.168.1.3',
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 10);
+        });
+
+        it('path matched, remoteAddr matched with IP in 192.168.1.0/24 subnet', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                remoteAddr: '192.168.1.100',
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 11);
+        });
+
+        it('path matched, host matched with IP in 192.168.0.0/16 subnet', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                remoteAddr: '192.168.2.1',
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 12);
+        });
+
+        it('path matched, but remoteAddr not matched', function () {
+            const result = tree.findRoute({
+                path: '/api/users/1',
+                method: 'GET',
+                remoteAddr: '10.0.0.1',
+            });
+            assert.strictEqual(result, null);
+        });
+
+
+        it('should match expression condition: age >= 10 and x_id divisible by 20', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { age: '25' },
+                headers: { 'x-id': '40' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 20);
+        });
+
+        it('should not match: empty variables', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: {},
+                headers: {},
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should not match: age < 10', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { age: '9' },
+                headers: { 'x-id': '40' },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should not match: x_id not divisible by 20', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { age: '25' },
+                headers: { 'x-id': '41' },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should match edge case: age = 10 and x_id = 0', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { age: '10' },
+                headers: { 'x-id': '0' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 20);
+        });
+
+        it('should match large numbers: both age and x_id are large', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { age: '100' },
+                headers: { 'x-id': '1000' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 20);
+        });
+
+        it('should match: name is tom', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { name: 'tom' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 21);
+        });
+
+        it('should match: name is lily', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { name: 'lily' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 21);
+        });
+
+        it('should not match: name is other value', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { name: 'john' },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should not match: name parameter missing', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: {},
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should match: name is tom (case sensitive)', function () {
+            const result = tree.findRoute({
+                path: '/api/users/profile',
+                method: 'GET',
+                args: { name: 'TOM' },
+            });
+            assert.strictEqual(result, null);
+        });
+    });
+
+    describe('Http Route Matching By Host Extension', function () {
+        let tree;
+
+        beforeEach(function () {
+            const routes = [
+                { paths: ['/**'], meta: { id: 30 }, hosts: ['example.com']},
+                { paths: ['/**'], meta: { id: 31 }, hosts: ['*.example.com']},
+                { paths: ['/**'], meta: { id: 32 }, hosts: ['api.example.com']}
+
+            ];
+            tree = new HttpRadixTree(routes);
+        });
+
+        it('should match exact host example.com', function () {
+            const result = tree.findRoute({
+                path: '/',
+                method: 'GET',
+                headers: { host: 'example.com' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 30);
+        });
+
+        it('should match wildcard subdomain of example.com', function () {
+            const result = tree.findRoute({
+                path: '/about',
+                method: 'GET',
+                headers: { host: 'blog.example.com' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 31);
+        });
+
+        it('should match specific subdomain api.example.com', function () {
+            const result = tree.findRoute({
+                path: '/users',
+                method: 'GET',
+                headers: { host: 'api.example.com' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 32);
+        });
+
+        it('should not match unrelated domain', function () {
+            const result = tree.findRoute({
+                path: '/',
+                method: 'GET',
+                headers: { host: 'unrelated.com' },
+            });
+            assert.strictEqual(result, null);
+        });
+
+        it('should match example.com with longer path', function () {
+            const result = tree.findRoute({
+                path: '/some/long/path',
+                method: 'GET',
+                headers: { host: 'example.com' },
+            });
+            assert.notStrictEqual(result, null);
+            assert.strictEqual(result.meta.id, 30);
+        });
+    });
+});