@rangojs/router 0.0.0-experimental.tapabs3 → 0.1.1

package/dist/host/__tests__/pattern-comprehensive.test.js

@@ -1,732 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { matchPattern } from '../pattern-matcher';
-describe('Comprehensive Pattern Testing - Apex Domains', () => {
-    const apexPatterns = ['.', '*'];
-    apexPatterns.forEach((pattern) => {
-        it(`${pattern} should match various apex domains`, () => {
-            const apexHosts = [
-                'example.com',
-                'google.com',
-                'localhost',
-                'test.dev',
-                'my-app.io',
-                'site123.net',
-                'example.co.uk', // Note: This is 3 parts but .co.uk is treated as TLD
-            ];
-            apexHosts.forEach((host) => {
-                const parts = host.split('.');
-                if (parts.length === 2) {
-                    expect(matchPattern(pattern, host, '/', parts)).toBe(true);
-                }
-            });
-        });
-        it(`${pattern} should NOT match subdomains`, () => {
-            const subdomainHosts = [
-                'www.example.com',
-                'api.google.com',
-                'admin.test.dev',
-                'staging.my-app.io',
-                'v2.api.example.com',
-            ];
-            subdomainHosts.forEach((host) => {
-                const parts = host.split('.');
-                expect(matchPattern(pattern, host, '/', parts)).toBe(false);
-            });
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Any Domain', () => {
-    it('** should match absolutely any domain', () => {
-        const allHosts = [
-            'example.com',
-            'www.example.com',
-            'api.example.com',
-            'a.b.c.example.com',
-            'deeply.nested.subdomain.example.com',
-            'localhost',
-            'test.dev',
-            'admin.staging.v2.example.io',
-        ];
-        allHosts.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('**', host, '/', parts)).toBe(true);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Single Subdomains', () => {
-    it('*. should match only single-level subdomains', () => {
-        const singleSubdomains = [
-            'www.example.com',
-            'api.google.com',
-            'admin.test.dev',
-            'staging.myapp.io',
-            'v1.service.net',
-            'blog.site.org',
-        ];
-        singleSubdomains.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.', host, '/', parts)).toBe(true);
-        });
-    });
-    it('*. should NOT match apex or multi-level', () => {
-        const nonMatching = [
-            'example.com', // Apex
-            'localhost', // Apex
-            'a.b.example.com', // Multi-level
-            'staging.api.example.com', // Multi-level
-        ];
-        nonMatching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.', host, '/', parts)).toBe(false);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Multi-level Subdomains', () => {
-    it('**. should match only multi-level subdomains (2+ levels)', () => {
-        const multiLevel = [
-            'a.b.example.com',
-            'staging.api.example.com',
-            'v2.admin.test.dev',
-            'pr-123.preview.myapp.io',
-            'deeply.nested.sub.domain.com',
-        ];
-        multiLevel.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('**.', host, '/', parts)).toBe(true);
-        });
-    });
-    it('**. should NOT match apex or single-level', () => {
-        const nonMatching = [
-            'example.com', // Apex
-            'www.example.com', // Single-level
-            'api.google.com', // Single-level
-        ];
-        nonMatching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('**.', host, '/', parts)).toBe(false);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - TLD Patterns', () => {
-    it('*.com should match any apex .com domain', () => {
-        const comDomains = [
-            'example.com',
-            'google.com',
-            'test.com',
-            'my-site.com',
-            'abc123.com',
-        ];
-        comDomains.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.com', host, '/', parts)).toBe(true);
-        });
-    });
-    it('*.com should NOT match non-.com or subdomains', () => {
-        const nonMatching = [
-            'example.net',
-            'google.io',
-            'www.example.com', // Subdomain
-            'api.google.com', // Subdomain
-        ];
-        nonMatching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.com', host, '/', parts)).toBe(false);
-        });
-    });
-    it('should match other TLDs', () => {
-        expect(matchPattern('*.dev', 'myapp.dev', '/', ['myapp', 'dev'])).toBe(true);
-        expect(matchPattern('*.io', 'service.io', '/', ['service', 'io'])).toBe(true);
-        expect(matchPattern('*.org', 'nonprofit.org', '/', ['nonprofit', 'org'])).toBe(true);
-        expect(matchPattern('*.net', 'example.net', '/', ['example', 'net'])).toBe(true);
-    });
-});
-describe('Comprehensive Pattern Testing - Specific Subdomains', () => {
-    const subdomainNames = ['admin', 'api', 'www', 'staging', 'v2', 'blog'];
-    subdomainNames.forEach((subdomain) => {
-        it(`${subdomain}.* should match ${subdomain} of any apex domain`, () => {
-            const hosts = [
-                `${subdomain}.example.com`,
-                `${subdomain}.google.com`,
-                `${subdomain}.test.dev`,
-                `${subdomain}.myapp.io`,
-            ];
-            hosts.forEach((host) => {
-                const parts = host.split('.');
-                expect(matchPattern(`${subdomain}.*`, host, '/', parts)).toBe(true);
-            });
-        });
-        it(`${subdomain}.* should NOT match different subdomains or multi-level`, () => {
-            const nonMatching = [
-                'example.com', // No subdomain
-                'other.example.com', // Different subdomain
-                `${subdomain}.sub.example.com`, // Multi-level
-                `pre-${subdomain}.example.com`, // Different prefix
-            ];
-            nonMatching.forEach((host) => {
-                const parts = host.split('.');
-                expect(matchPattern(`${subdomain}.*`, host, '/', parts)).toBe(false);
-            });
-        });
-        it(`${subdomain}.** should match ${subdomain} of any domain depth`, () => {
-            const hosts = [
-                `${subdomain}.example.com`,
-                `${subdomain}.sub.example.com`,
-                `${subdomain}.a.b.c.example.com`,
-            ];
-            hosts.forEach((host) => {
-                const parts = host.split('.');
-                expect(matchPattern(`${subdomain}.**`, host, '/', parts)).toBe(true);
-            });
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Domain-Specific Patterns', () => {
-    it('*.example.com should match single subdomains only', () => {
-        const matching = [
-            'www.example.com',
-            'api.example.com',
-            'staging.example.com',
-            'v2.example.com',
-            'admin.example.com',
-        ];
-        matching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.example.com', host, '/', parts)).toBe(true);
-        });
-    });
-    it('*.example.com should NOT match apex, multi-level, or other domains', () => {
-        const nonMatching = [
-            'example.com', // Apex
-            'a.b.example.com', // Multi-level
-            'api.google.com', // Different domain
-            'example.net', // Different domain
-        ];
-        nonMatching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('*.example.com', host, '/', parts)).toBe(false);
-        });
-    });
-    it('**.example.com should match any depth subdomains', () => {
-        const matching = [
-            'api.example.com',
-            'a.b.example.com',
-            'staging.api.example.com',
-            'deeply.nested.sub.example.com',
-        ];
-        matching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('**.example.com', host, '/', parts)).toBe(true);
-        });
-    });
-    it('**.example.com should NOT match apex or other domains', () => {
-        const nonMatching = [
-            'example.com', // Apex
-            'api.google.com', // Different domain
-            'example.net', // Different domain
-        ];
-        nonMatching.forEach((host) => {
-            const parts = host.split('.');
-            expect(matchPattern('**.example.com', host, '/', parts)).toBe(false);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Path Patterns', () => {
-    const pathCombinations = [
-        {
-            pattern: './admin',
-            host: 'example.com',
-            paths: ['/admin', '/admin/users', '/admin/settings/profile'],
-        },
-        {
-            pattern: './api',
-            host: 'test.dev',
-            paths: ['/api', '/api/v2', '/api/v2/users'],
-        },
-        {
-            pattern: './blog',
-            host: 'mysite.io',
-            paths: ['/blog', '/blog/post-1', '/blog/2024/january'],
-        },
-        {
-            pattern: '*./dashboard',
-            host: 'app.example.com',
-            paths: ['/dashboard', '/dashboard/settings'],
-        },
-        {
-            pattern: '*./api',
-            host: 'v2.example.com',
-            paths: ['/api', '/api/users', '/api/v1/posts'],
-        },
-        {
-            pattern: 'admin./settings',
-            host: 'admin.example.com',
-            paths: ['/settings', '/settings/user'],
-        },
-        {
-            pattern: '**/health',
-            host: 'example.com',
-            paths: ['/health', '/health/check'],
-        },
-        {
-            pattern: '**/health',
-            host: 'api.example.com',
-            paths: ['/health', '/health/status'],
-        },
-    ];
-    pathCombinations.forEach(({ pattern, host, paths }) => {
-        it(`${pattern} should match ${host} with correct paths`, () => {
-            const parts = host.split('.');
-            paths.forEach((path) => {
-                expect(matchPattern(pattern, host, path, parts)).toBe(true);
-            });
-        });
-        it(`${pattern} should NOT match ${host} with wrong paths`, () => {
-            const parts = host.split('.');
-            const wrongPaths = ['/other', '/different', '/notmatching'];
-            wrongPaths.forEach((path) => {
-                expect(matchPattern(pattern, host, path, parts)).toBe(false);
-            });
-        });
-    });
-    it("should NOT match path when domain doesn't match", () => {
-        expect(matchPattern('./admin', 'www.example.com', '/admin', [
-            'www',
-            'example',
-            'com',
-        ])).toBe(false);
-        expect(matchPattern('*./api', 'example.com', '/api', ['example', 'com'])).toBe(false);
-        expect(matchPattern('admin./blog', 'api.example.com', '/blog', [
-            'api',
-            'example',
-            'com',
-        ])).toBe(false);
-    });
-});
-describe('Comprehensive Pattern Testing - Exact Matches', () => {
-    it('should match exact domain patterns', () => {
-        const exactMatches = [
-            { pattern: 'example.com', host: 'example.com' },
-            { pattern: 'google.com', host: 'google.com' },
-            { pattern: 'test.dev', host: 'test.dev' },
-            { pattern: 'www.example.com', host: 'www.example.com' },
-            { pattern: 'api.google.com', host: 'api.google.com' },
-            {
-                pattern: 'admin.staging.example.com',
-                host: 'admin.staging.example.com',
-            },
-            { pattern: 'localhost', host: 'localhost' },
-        ];
-        exactMatches.forEach(({ pattern, host }) => {
-            const parts = host.split('.');
-            expect(matchPattern(pattern, host, '/', parts)).toBe(true);
-        });
-    });
-    it('should NOT match similar but different domains', () => {
-        expect(matchPattern('example.com', 'examples.com', '/', ['examples', 'com'])).toBe(false);
-        expect(matchPattern('www.example.com', 'ww.example.com', '/', [
-            'ww',
-            'example',
-            'com',
-        ])).toBe(false);
-        expect(matchPattern('api.example.com', 'api.examples.com', '/', [
-            'api',
-            'examples',
-            'com',
-        ])).toBe(false);
-    });
-    it('should match exact domain with path', () => {
-        const exactPathMatches = [
-            { pattern: 'example.com/admin', host: 'example.com', path: '/admin' },
-            {
-                pattern: 'example.com/admin',
-                host: 'example.com',
-                path: '/admin/users',
-            },
-            { pattern: 'api.example.com/v2', host: 'api.example.com', path: '/v2' },
-            {
-                pattern: 'api.example.com/v2',
-                host: 'api.example.com',
-                path: '/v2/users',
-            },
-            { pattern: 'localhost/api', host: 'localhost', path: '/api' },
-            { pattern: 'localhost/api', host: 'localhost', path: '/api/test' },
-        ];
-        exactPathMatches.forEach(({ pattern, host, path }) => {
-            const parts = host.split('.');
-            expect(matchPattern(pattern, host, path, parts)).toBe(true);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Complex Scenarios', () => {
-    it('should handle patterns with hyphens in names', () => {
-        expect(matchPattern('my-app.*', 'my-app.example.com', '/', [
-            'my-app',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('*.my-site.com', 'api.my-site.com', '/', [
-            'api',
-            'my-site',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('staging-v2.*', 'staging-v2.example.com', '/', [
-            'staging-v2',
-            'example',
-            'com',
-        ])).toBe(true);
-    });
-    it('should handle patterns with numbers', () => {
-        expect(matchPattern('v2.*', 'v2.example.com', '/', ['v2', 'example', 'com'])).toBe(true);
-        expect(matchPattern('api2.*', 'api2.google.com', '/', ['api2', 'google', 'com'])).toBe(true);
-        expect(matchPattern('*.v3.com', 'test.v3.com', '/', ['test', 'v3', 'com'])).toBe(true);
-    });
-    it('should handle localhost variants', () => {
-        expect(matchPattern('localhost', 'localhost', '/', ['localhost'])).toBe(true);
-        expect(matchPattern('.', 'localhost', '/', ['localhost'])).toBe(false); // localhost is 1 part, not apex
-        expect(matchPattern('*.localhost', 'admin.localhost', '/', [
-            'admin',
-            'localhost',
-        ])).toBe(true);
-    });
-    it('should handle different TLD lengths', () => {
-        // 2-letter TLDs
-        expect(matchPattern('*.io', 'example.io', '/', ['example', 'io'])).toBe(true);
-        expect(matchPattern('*.uk', 'example.uk', '/', ['example', 'uk'])).toBe(true);
-        // 3-letter TLDs
-        expect(matchPattern('*.com', 'example.com', '/', ['example', 'com'])).toBe(true);
-        expect(matchPattern('*.dev', 'example.dev', '/', ['example', 'dev'])).toBe(true);
-        expect(matchPattern('*.org', 'example.org', '/', ['example', 'org'])).toBe(true);
-        // 4-letter TLDs
-        expect(matchPattern('*.info', 'example.info', '/', ['example', 'info'])).toBe(true);
-    });
-});
-describe('Comprehensive Pattern Testing - Path Edge Cases', () => {
-    it('should match paths with various depths', () => {
-        const matchingPaths = ['/a', '/a/b', '/a/b/c'];
-        const nonMatchingPaths = [
-            '/api/v2/users/123',
-            '/admin/settings/profile/security',
-            '/b',
-        ];
-        matchingPaths.forEach((path) => {
-            expect(matchPattern('./a', 'example.com', path, ['example', 'com'])).toBe(true);
-        });
-        nonMatchingPaths.forEach((path) => {
-            expect(matchPattern('./a', 'example.com', path, ['example', 'com'])).toBe(false);
-        });
-    });
-    it('should match paths with special characters', () => {
-        const paths = ['/api-v2', '/api_v2', '/admin-panel', '/user_settings'];
-        paths.forEach((path) => {
-            const pattern = `.${path}`;
-            expect(matchPattern(pattern, 'example.com', path, ['example', 'com'])).toBe(true);
-            expect(matchPattern(pattern, 'example.com', path + '/sub', ['example', 'com'])).toBe(true);
-        });
-    });
-    it("should NOT match when path doesn't start correctly", () => {
-        expect(matchPattern('./admin', 'example.com', '/administrator', [
-            'example',
-            'com',
-        ])).toBe(false);
-        expect(matchPattern('./api', 'example.com', '/apis', ['example', 'com'])).toBe(false);
-        expect(matchPattern('./blog', 'example.com', '/blogs', ['example', 'com'])).toBe(false);
-    });
-    it('should handle root path', () => {
-        expect(matchPattern('.', 'example.com', '/', ['example', 'com'])).toBe(true);
-        expect(matchPattern('admin.*', 'admin.example.com', '/', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('**', 'any.domain.com', '/', ['any', 'domain', 'com'])).toBe(true);
-    });
-});
-describe('Comprehensive Pattern Testing - Subdomain with Patterns', () => {
-    it('admin. should match admin subdomain with trailing dot', () => {
-        expect(matchPattern('admin.', 'admin.example.com', '/', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('admin.', 'admin.google.com', '/', [
-            'admin',
-            'google',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('api.', 'api.test.dev', '/', ['api', 'test', 'dev'])).toBe(true);
-    });
-    it('subdomain. should NOT match wrong subdomain or multi-level', () => {
-        expect(matchPattern('admin.', 'api.example.com', '/', ['api', 'example', 'com'])).toBe(false);
-        expect(matchPattern('admin.', 'admin.sub.example.com', '/', [
-            'admin',
-            'sub',
-            'example',
-            'com',
-        ])).toBe(false);
-        expect(matchPattern('admin.', 'example.com', '/', ['example', 'com'])).toBe(false);
-    });
-});
-describe('Comprehensive Pattern Testing - Mixed Patterns', () => {
-    it('should handle subdomain + specific domain patterns', () => {
-        expect(matchPattern('*.example.com', 'www.example.com', '/', [
-            'www',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('*.example.com', 'api.example.com', '/', [
-            'api',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('**.example.com', 'a.b.example.com', '/', [
-            'a',
-            'b',
-            'example',
-            'com',
-        ])).toBe(true);
-    });
-    it('should handle subdomain + TLD patterns', () => {
-        expect(matchPattern('admin.*', 'admin.example.com', '/', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('admin.*', 'admin.test.dev', '/', ['admin', 'test', 'dev'])).toBe(true);
-        expect(matchPattern('admin.*', 'admin.myapp.io', '/', ['admin', 'myapp', 'io'])).toBe(true);
-    });
-    it('should handle path patterns with domain specificity', () => {
-        // Specific domain + path
-        expect(matchPattern('example.com/api', 'example.com', '/api', ['example', 'com'])).toBe(true);
-        expect(matchPattern('example.com/api', 'example.com', '/api/v2', [
-            'example',
-            'com',
-        ])).toBe(true);
-        // Any apex + path
-        expect(matchPattern('./admin', 'example.com', '/admin', ['example', 'com'])).toBe(true);
-        expect(matchPattern('./admin', 'google.com', '/admin', ['google', 'com'])).toBe(true);
-        // Subdomain pattern + path
-        expect(matchPattern('*./api', 'v2.example.com', '/api', ['v2', 'example', 'com'])).toBe(true);
-        expect(matchPattern('admin./settings', 'admin.example.com', '/settings', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-    });
-});
-describe('Comprehensive Pattern Testing - Edge Cases', () => {
-    it('should handle single-part domains (localhost)', () => {
-        expect(matchPattern('localhost', 'localhost', '/', ['localhost'])).toBe(true);
-        expect(matchPattern('.', 'localhost', '/', ['localhost'])).toBe(false); // . requires 2 parts
-        expect(matchPattern('**', 'localhost', '/', ['localhost'])).toBe(true);
-    });
-    it('should handle very long subdomains', () => {
-        const longHost = 'a.b.c.d.e.f.g.example.com';
-        const parts = longHost.split('.');
-        expect(matchPattern('**.', longHost, '/', parts)).toBe(true);
-        expect(matchPattern('**.example.com', longHost, '/', parts)).toBe(true);
-        expect(matchPattern('**', longHost, '/', parts)).toBe(true);
-        expect(matchPattern('*.', longHost, '/', parts)).toBe(false); // Too many levels
-    });
-    it('should NOT match patterns that are close but wrong', () => {
-        // Similar prefixes
-        expect(matchPattern('api.*', 'apis.example.com', '/', ['apis', 'example', 'com'])).toBe(false);
-        expect(matchPattern('admin.*', 'administrator.example.com', '/', [
-            'administrator',
-            'example',
-            'com',
-        ])).toBe(false);
-        // Similar paths
-        expect(matchPattern('./admin', 'example.com', '/admins', ['example', 'com'])).toBe(false);
-        expect(matchPattern('./api', 'example.com', '/api-v2', ['example', 'com'])).toBe(false);
-    });
-    it('should handle case sensitivity correctly', () => {
-        // Hostnames should be case-insensitive (per spec)
-        // But our implementation treats them as-is
-        expect(matchPattern('Admin.*', 'Admin.example.com', '/', [
-            'Admin',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('admin.*', 'Admin.example.com', '/', [
-            'Admin',
-            'example',
-            'com',
-        ])).toBe(false);
-    });
-});
-describe('Comprehensive Pattern Testing - Multiple Specific Domains', () => {
-    it('should match various domain-specific patterns', () => {
-        const tests = [
-            { pattern: 'example.com', host: 'example.com' },
-            { pattern: 'google.com', host: 'google.com' },
-            { pattern: 'api.example.com', host: 'api.example.com' },
-            { pattern: 'staging.api.example.com', host: 'staging.api.example.com' },
-            { pattern: 'v2.admin.test.dev', host: 'v2.admin.test.dev' },
-        ];
-        tests.forEach(({ pattern, host }) => {
-            const parts = host.split('.');
-            expect(matchPattern(pattern, host, '/', parts)).toBe(true);
-        });
-    });
-    it('should match specific domain with various paths', () => {
-        const tests = [
-            { pattern: 'example.com/api', host: 'example.com', path: '/api' },
-            { pattern: 'example.com/api', host: 'example.com', path: '/api/v2' },
-            { pattern: 'example.com/api/v2', host: 'example.com', path: '/api/v2' },
-            {
-                pattern: 'example.com/api/v2',
-                host: 'example.com',
-                path: '/api/v2/users',
-            },
-            {
-                pattern: 'admin.example.com/dashboard',
-                host: 'admin.example.com',
-                path: '/dashboard',
-            },
-        ];
-        tests.forEach(({ pattern, host, path }) => {
-            const parts = host.split('.');
-            expect(matchPattern(pattern, host, path, parts)).toBe(true);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Wildcard Combinations', () => {
-    it('should test all wildcard combinations', () => {
-        const wildcardsTests = [
-            // Apex wildcards
-            { pattern: '.', host: 'example.com', match: true },
-            { pattern: '*', host: 'example.com', match: true },
-            { pattern: '.', host: 'www.example.com', match: false },
-            // Subdomain wildcards
-            { pattern: '*.', host: 'www.example.com', match: true },
-            { pattern: '*.', host: 'api.test.dev', match: true },
-            { pattern: '**.', host: 'a.b.example.com', match: true },
-            { pattern: '**.', host: 'x.y.z.test.dev', match: true },
-            // Domain wildcards
-            { pattern: '**', host: 'example.com', match: true },
-            { pattern: '**', host: 'www.example.com', match: true },
-            { pattern: '**', host: 'a.b.c.example.com', match: true },
-            // Subdomain + wildcard TLD
-            { pattern: 'admin.*', host: 'admin.example.com', match: true },
-            { pattern: 'admin.*', host: 'admin.test.dev', match: true },
-            { pattern: 'admin.**', host: 'admin.sub.example.com', match: true },
-            // Wildcard + specific domain
-            { pattern: '*.example.com', host: 'api.example.com', match: true },
-            { pattern: '**.example.com', host: 'a.b.example.com', match: true },
-        ];
-        wildcardsTests.forEach(({ pattern, host, match }) => {
-            const parts = host.split('.');
-            expect(matchPattern(pattern, host, '/', parts)).toBe(match);
-        });
-    });
-});
-describe('Comprehensive Pattern Testing - Real-World Scenarios', () => {
-    it('should handle typical SaaS multi-tenant patterns', () => {
-        // Company subdomains
-        expect(matchPattern('*.', 'acme.myapp.com', '/', ['acme', 'myapp', 'com'])).toBe(true);
-        expect(matchPattern('*.', 'bigcorp.myapp.com', '/', ['bigcorp', 'myapp', 'com'])).toBe(true);
-        // Reserved subdomains
-        expect(matchPattern('www.*', 'www.myapp.com', '/', ['www', 'myapp', 'com'])).toBe(true);
-        expect(matchPattern('admin.*', 'admin.myapp.com', '/', ['admin', 'myapp', 'com'])).toBe(true);
-        expect(matchPattern('api.*', 'api.myapp.com', '/', ['api', 'myapp', 'com'])).toBe(true);
-    });
-    it('should handle staging/preview environments', () => {
-        expect(matchPattern('staging.*', 'staging.example.com', '/', [
-            'staging',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('preview.*', 'preview.example.com', '/', [
-            'preview',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('**.', 'pr-123.preview.example.com', '/', [
-            'pr-123',
-            'preview',
-            'example',
-            'com',
-        ])).toBe(true);
-    });
-    it('should handle API versioning patterns', () => {
-        expect(matchPattern('api./v1', 'api.example.com', '/v1', [
-            'api',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('api./v2', 'api.example.com', '/v2', [
-            'api',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('*./v3', 'v3.example.com', '/v3', ['v3', 'example', 'com'])).toBe(true);
-    });
-    it('should handle admin panel patterns', () => {
-        expect(matchPattern('./admin', 'example.com', '/admin', ['example', 'com'])).toBe(true);
-        expect(matchPattern('admin.*', 'admin.example.com', '/dashboard', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('admin./dashboard', 'admin.example.com', '/dashboard', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(true);
-    });
-    it('should handle documentation sites', () => {
-        expect(matchPattern('docs.*', 'docs.example.com', '/', [
-            'docs',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('*.example.com', 'docs.example.com', '/', [
-            'docs',
-            'example',
-            'com',
-        ])).toBe(true);
-        expect(matchPattern('./docs', 'example.com', '/docs', ['example', 'com'])).toBe(true);
-    });
-});
-describe('Comprehensive Pattern Testing - Negative Cases', () => {
-    it("should NOT match when parts don't align", () => {
-        // Subdomain pattern on apex
-        expect(matchPattern('*.', 'example.com', '/', ['example', 'com'])).toBe(false);
-        // Apex pattern on subdomain
-        expect(matchPattern('.', 'www.example.com', '/', ['www', 'example', 'com'])).toBe(false);
-        // Multi-level pattern on single-level
-        expect(matchPattern('**.', 'www.example.com', '/', ['www', 'example', 'com'])).toBe(false);
-    });
-    it("should NOT match when TLDs don't align", () => {
-        expect(matchPattern('*.com', 'example.net', '/', ['example', 'net'])).toBe(false);
-        expect(matchPattern('*.dev', 'example.com', '/', ['example', 'com'])).toBe(false);
-        expect(matchPattern('*.example.com', 'api.example.net', '/', [
-            'api',
-            'example',
-            'net',
-        ])).toBe(false);
-    });
-    it("should NOT match when subdomain name doesn't match", () => {
-        expect(matchPattern('admin.*', 'api.example.com', '/', ['api', 'example', 'com'])).toBe(false);
-        expect(matchPattern('www.*', 'api.example.com', '/', ['api', 'example', 'com'])).toBe(false);
-        expect(matchPattern('staging.*', 'production.example.com', '/', [
-            'production',
-            'example',
-            'com',
-        ])).toBe(false);
-    });
-    it("should NOT match when paths don't match", () => {
-        expect(matchPattern('./admin', 'example.com', '/api', ['example', 'com'])).toBe(false);
-        expect(matchPattern('*./api', 'api.example.com', '/admin', [
-            'api',
-            'example',
-            'com',
-        ])).toBe(false);
-        expect(matchPattern('admin./blog', 'admin.example.com', '/admin', [
-            'admin',
-            'example',
-            'com',
-        ])).toBe(false);
-    });
-});
-//# sourceMappingURL=pattern-comprehensive.test.js.map