domain-search-mcp 1.0.0

package/tests/premium-analyzer.test.ts

@@ -0,0 +1,310 @@
+/**
+ * Tests for Premium Domain Analyzer.
+ */
+
+import { describe, expect, it } from '@jest/globals';
+import {
+  analyzePremiumReason,
+  generatePremiumInsight,
+  suggestPremiumAlternatives,
+  calculateDomainScore,
+  generatePremiumSummary,
+} from '../src/utils/premium-analyzer.js';
+import type { DomainResult } from '../src/types.js';
+
+describe('Premium Analyzer', () => {
+  describe('analyzePremiumReason', () => {
+    it('should detect single character domains', () => {
+      const reasons = analyzePremiumReason('x.com');
+      expect(reasons).toContain('Single character domain (extremely rare)');
+    });
+
+    it('should detect two-character domains', () => {
+      const reasons = analyzePremiumReason('ai.io');
+      expect(reasons.some(r => r.includes('Two-character'))).toBe(true);
+    });
+
+    it('should detect three-character domains', () => {
+      const reasons = analyzePremiumReason('app.dev');
+      expect(reasons.some(r => r.includes('Three-character'))).toBe(true);
+    });
+
+    it('should detect premium keywords', () => {
+      const reasons = analyzePremiumReason('cloud.io');
+      expect(reasons.some(r => r.includes('Popular keyword'))).toBe(true);
+    });
+
+    it('should detect numeric patterns', () => {
+      const reasons = analyzePremiumReason('123.com');
+      expect(reasons.some(r => r.includes('numeric pattern'))).toBe(true);
+    });
+
+    it('should detect repeating characters', () => {
+      const reasons = analyzePremiumReason('aaa.io');
+      expect(reasons.some(r => r.includes('Repeating character'))).toBe(true);
+    });
+
+    it('should detect high-demand TLDs', () => {
+      const reasons = analyzePremiumReason('mysite.io');
+      expect(reasons.some(r => r.includes('High-demand .io'))).toBe(true);
+    });
+
+    it('should return empty for non-premium domains', () => {
+      const reasons = analyzePremiumReason('myawesomewebsite.net');
+      // Long, non-keyword domain on .net should have no premium reasons
+      expect(reasons.length).toBe(0);
+    });
+  });
+
+  describe('generatePremiumInsight', () => {
+    it('should generate insight for premium domain with price', () => {
+      const result: DomainResult = {
+        domain: 'ai.io',
+        available: true,
+        premium: true,
+        price_first_year: 5000,
+        price_renewal: 500,
+        currency: 'USD',
+        privacy_included: false,
+        transfer_price: null,
+        registrar: 'porkbun',
+        source: 'porkbun_api',
+        checked_at: new Date().toISOString(),
+      };
+
+      const insight = generatePremiumInsight(result);
+      expect(insight).not.toBeNull();
+      expect(insight).toContain('ai.io');
+      expect(insight).toContain('$5000');
+    });
+
+    it('should return null for non-premium domains', () => {
+      const result: DomainResult = {
+        domain: 'mywebsite.com',
+        available: true,
+        premium: false,
+        price_first_year: 10,
+        price_renewal: 12,
+        currency: 'USD',
+        privacy_included: true,
+        transfer_price: null,
+        registrar: 'porkbun',
+        source: 'porkbun_api',
+        checked_at: new Date().toISOString(),
+      };
+
+      const insight = generatePremiumInsight(result);
+      expect(insight).toBeNull();
+    });
+
+    it('should return null for unavailable domains', () => {
+      const result: DomainResult = {
+        domain: 'google.com',
+        available: false,
+        premium: true,
+        price_first_year: null,
+        price_renewal: null,
+        currency: 'USD',
+        privacy_included: false,
+        transfer_price: null,
+        registrar: 'rdap',
+        source: 'rdap',
+        checked_at: new Date().toISOString(),
+      };
+
+      const insight = generatePremiumInsight(result);
+      expect(insight).toBeNull();
+    });
+  });
+
+  describe('suggestPremiumAlternatives', () => {
+    it('should suggest alternatives for premium domain', () => {
+      const alternatives = suggestPremiumAlternatives('app.io');
+      expect(alternatives.length).toBeGreaterThan(0);
+      expect(alternatives.length).toBeLessThanOrEqual(3);
+    });
+
+    it('should include prefix variations', () => {
+      const alternatives = suggestPremiumAlternatives('cloud.com');
+      const hasPrefix = alternatives.some(a =>
+        a.startsWith('get') || a.startsWith('try') || a.startsWith('use') ||
+        a.startsWith('my') || a.startsWith('the') || a.startsWith('go')
+      );
+      expect(hasPrefix).toBe(true);
+    });
+
+    it('should include suffix variations', () => {
+      const alternatives = suggestPremiumAlternatives('tech.io');
+      const hasSuffix = alternatives.some(a =>
+        a.includes('app') || a.includes('hq') || a.includes('io') ||
+        a.includes('now') || a.includes('hub') || a.includes('labs')
+      );
+      expect(hasSuffix).toBe(true);
+    });
+  });
+
+  describe('calculateDomainScore', () => {
+    it('should return 0 for unavailable domains', () => {
+      const result: DomainResult = {
+        domain: 'taken.com',
+        available: false,
+        premium: false,
+        price_first_year: null,
+        price_renewal: null,
+        currency: 'USD',
+        privacy_included: false,
+        transfer_price: null,
+        registrar: 'rdap',
+        source: 'rdap',
+        checked_at: new Date().toISOString(),
+      };
+
+      expect(calculateDomainScore(result)).toBe(0);
+    });
+
+    it('should give higher score for domains with privacy', () => {
+      const withPrivacy: DomainResult = {
+        domain: 'test.com',
+        available: true,
+        premium: false,
+        price_first_year: 10,
+        price_renewal: 12,
+        currency: 'USD',
+        privacy_included: true,
+        transfer_price: null,
+        registrar: 'porkbun',
+        source: 'porkbun_api',
+        checked_at: new Date().toISOString(),
+      };
+
+      const withoutPrivacy: DomainResult = {
+        ...withPrivacy,
+        privacy_included: false,
+      };
+
+      expect(calculateDomainScore(withPrivacy)).toBeGreaterThan(calculateDomainScore(withoutPrivacy));
+    });
+
+    it('should penalize premium domains', () => {
+      const nonPremium: DomainResult = {
+        domain: 'test.com',
+        available: true,
+        premium: false,
+        price_first_year: 10,
+        price_renewal: 12,
+        currency: 'USD',
+        privacy_included: false,
+        transfer_price: null,
+        registrar: 'porkbun',
+        source: 'porkbun_api',
+        checked_at: new Date().toISOString(),
+      };
+
+      const premium: DomainResult = {
+        ...nonPremium,
+        premium: true,
+      };
+
+      expect(calculateDomainScore(nonPremium)).toBeGreaterThan(calculateDomainScore(premium));
+    });
+
+    it('should return score between 0 and 10', () => {
+      const result: DomainResult = {
+        domain: 'mybrand.io',
+        available: true,
+        premium: false,
+        price_first_year: 40,
+        price_renewal: 50,
+        currency: 'USD',
+        privacy_included: true,
+        transfer_price: null,
+        registrar: 'porkbun',
+        source: 'porkbun_api',
+        checked_at: new Date().toISOString(),
+      };
+
+      const score = calculateDomainScore(result);
+      expect(score).toBeGreaterThanOrEqual(0);
+      expect(score).toBeLessThanOrEqual(10);
+    });
+  });
+
+  describe('generatePremiumSummary', () => {
+    it('should return empty array when no premium domains', () => {
+      const results: DomainResult[] = [
+        {
+          domain: 'mybrand.com',
+          available: true,
+          premium: false,
+          price_first_year: 10,
+          price_renewal: 12,
+          currency: 'USD',
+          privacy_included: true,
+          transfer_price: null,
+          registrar: 'porkbun',
+          source: 'porkbun_api',
+          checked_at: new Date().toISOString(),
+        },
+      ];
+
+      const summary = generatePremiumSummary(results);
+      expect(summary).toEqual([]);
+    });
+
+    it('should generate summary for premium domains', () => {
+      const results: DomainResult[] = [
+        {
+          domain: 'ai.io',
+          available: true,
+          premium: true,
+          price_first_year: 5000,
+          price_renewal: 500,
+          currency: 'USD',
+          privacy_included: false,
+          transfer_price: null,
+          registrar: 'porkbun',
+          source: 'porkbun_api',
+          checked_at: new Date().toISOString(),
+        },
+      ];
+
+      const summary = generatePremiumSummary(results);
+      expect(summary.length).toBeGreaterThan(0);
+    });
+
+    it('should suggest alternatives when all available domains are premium', () => {
+      const results: DomainResult[] = [
+        {
+          domain: 'cloud.io',
+          available: true,
+          premium: true,
+          price_first_year: 2000,
+          price_renewal: 200,
+          currency: 'USD',
+          privacy_included: false,
+          transfer_price: null,
+          registrar: 'porkbun',
+          source: 'porkbun_api',
+          checked_at: new Date().toISOString(),
+        },
+        {
+          domain: 'cloud.com',
+          available: false,
+          premium: false,
+          price_first_year: null,
+          price_renewal: null,
+          currency: 'USD',
+          privacy_included: false,
+          transfer_price: null,
+          registrar: 'rdap',
+          source: 'rdap',
+          checked_at: new Date().toISOString(),
+        },
+      ];
+
+      const summary = generatePremiumSummary(results);
+      const hasSuggestion = summary.some(s => s.includes('Try:'));
+      expect(hasSuggestion).toBe(true);
+    });
+  });
+});

package/tests/unit/cache.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Unit Tests for TTL Cache.
+ */
+
+import { TtlCache, domainCacheKey, tldCacheKey, getOrCompute } from '../../src/utils/cache';
+
+describe('TtlCache', () => {
+  let cache: TtlCache<string>;
+
+  beforeEach(() => {
+    cache = new TtlCache<string>(1); // 1 second TTL
+  });
+
+  afterEach(() => {
+    cache.destroy();
+  });
+
+  it('should store and retrieve values', () => {
+    cache.set('key1', 'value1');
+    expect(cache.get('key1')).toBe('value1');
+  });
+
+  it('should return undefined for missing keys', () => {
+    expect(cache.get('nonexistent')).toBeUndefined();
+  });
+
+  it('should track cache size', () => {
+    expect(cache.size).toBe(0);
+    cache.set('key1', 'value1');
+    expect(cache.size).toBe(1);
+    cache.set('key2', 'value2');
+    expect(cache.size).toBe(2);
+  });
+
+  it('should delete keys', () => {
+    cache.set('key1', 'value1');
+    expect(cache.has('key1')).toBe(true);
+    cache.delete('key1');
+    expect(cache.has('key1')).toBe(false);
+  });
+
+  it('should clear all entries', () => {
+    cache.set('key1', 'value1');
+    cache.set('key2', 'value2');
+    cache.clear();
+    expect(cache.size).toBe(0);
+    expect(cache.get('key1')).toBeUndefined();
+  });
+
+  it('should expire entries after TTL', async () => {
+    cache.set('key1', 'value1');
+    expect(cache.get('key1')).toBe('value1');
+
+    // Wait for TTL to expire
+    await new Promise((resolve) => setTimeout(resolve, 1100));
+
+    expect(cache.get('key1')).toBeUndefined();
+  });
+
+  it('should allow custom TTL per entry', async () => {
+    cache.set('key1', 'value1', 100); // 100ms TTL
+    expect(cache.get('key1')).toBe('value1');
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    expect(cache.get('key1')).toBeUndefined();
+  });
+});
+
+describe('Cache Key Generators', () => {
+  it('should generate domain cache keys', () => {
+    expect(domainCacheKey('vibecoding.com', 'porkbun')).toBe(
+      'domain:vibecoding.com:porkbun',
+    );
+    expect(domainCacheKey('TEST.IO', 'rdap')).toBe('domain:test.io:rdap');
+  });
+
+  it('should generate TLD cache keys', () => {
+    expect(tldCacheKey('com')).toBe('tld:com');
+    expect(tldCacheKey('IO')).toBe('tld:io');
+  });
+});
+
+describe('getOrCompute', () => {
+  let cache: TtlCache<string>;
+
+  beforeEach(() => {
+    cache = new TtlCache<string>(60);
+  });
+
+  afterEach(() => {
+    cache.destroy();
+  });
+
+  it('should compute and cache value on first call', async () => {
+    let computeCount = 0;
+    const compute = async () => {
+      computeCount++;
+      return 'computed';
+    };
+
+    const result = await getOrCompute(cache, 'key1', compute);
+
+    expect(result.value).toBe('computed');
+    expect(result.fromCache).toBe(false);
+    expect(computeCount).toBe(1);
+  });
+
+  it('should return cached value on subsequent calls', async () => {
+    let computeCount = 0;
+    const compute = async () => {
+      computeCount++;
+      return 'computed';
+    };
+
+    await getOrCompute(cache, 'key1', compute);
+    const result = await getOrCompute(cache, 'key1', compute);
+
+    expect(result.value).toBe('computed');
+    expect(result.fromCache).toBe(true);
+    expect(computeCount).toBe(1); // Compute only called once
+  });
+});

package/tests/unit/errors.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Unit Tests for Custom Errors.
+ */
+
+import {
+  DomainSearchError,
+  InvalidDomainError,
+  UnsupportedTldError,
+  RateLimitError,
+  RegistrarApiError,
+  AuthenticationError,
+  NoSourceAvailableError,
+  TimeoutError,
+  ConfigurationError,
+  wrapError,
+} from '../../src/utils/errors';
+
+describe('DomainSearchError', () => {
+  it('should create error with all properties', () => {
+    const error = new DomainSearchError(
+      'TEST_CODE',
+      'Technical message',
+      'User-friendly message',
+      {
+        retryable: true,
+        suggestedAction: 'Try again',
+      },
+    );
+
+    expect(error.code).toBe('TEST_CODE');
+    expect(error.message).toBe('Technical message');
+    expect(error.userMessage).toBe('User-friendly message');
+    expect(error.retryable).toBe(true);
+    expect(error.suggestedAction).toBe('Try again');
+  });
+
+  it('should convert to JSON correctly', () => {
+    const error = new DomainSearchError(
+      'TEST_CODE',
+      'Technical message',
+      'User-friendly message',
+      { retryable: false },
+    );
+
+    const json = error.toJSON();
+
+    expect(json).toEqual({
+      code: 'TEST_CODE',
+      message: 'User-friendly message',
+      retryable: false,
+      suggestedAction: undefined,
+    });
+  });
+});
+
+describe('InvalidDomainError', () => {
+  it('should create with domain and reason', () => {
+    const error = new InvalidDomainError('my_domain', 'Contains underscore');
+
+    expect(error.code).toBe('INVALID_DOMAIN');
+    expect(error.message).toContain('my_domain');
+    expect(error.message).toContain('Contains underscore');
+    expect(error.retryable).toBe(false);
+  });
+});
+
+describe('UnsupportedTldError', () => {
+  it('should create with TLD and suggestions', () => {
+    const error = new UnsupportedTldError('xyz', ['com', 'io', 'dev']);
+
+    expect(error.code).toBe('UNSUPPORTED_TLD');
+    expect(error.message).toContain('.xyz');
+    expect(error.suggestedAction).toContain('com');
+    expect(error.retryable).toBe(false);
+  });
+});
+
+describe('RateLimitError', () => {
+  it('should create with registrar name', () => {
+    const error = new RateLimitError('porkbun');
+
+    expect(error.code).toBe('RATE_LIMIT');
+    expect(error.message).toContain('porkbun');
+    expect(error.retryable).toBe(true);
+  });
+
+  it('should include retry-after time', () => {
+    const error = new RateLimitError('porkbun', 30);
+
+    expect(error.suggestedAction).toContain('30 seconds');
+    expect(error.retryAfter).toBeDefined();
+  });
+});
+
+describe('RegistrarApiError', () => {
+  it('should create with registrar and message', () => {
+    const error = new RegistrarApiError('namecheap', 'Connection failed');
+
+    expect(error.code).toBe('REGISTRAR_API_ERROR');
+    expect(error.message).toContain('namecheap');
+    expect(error.message).toContain('Connection failed');
+  });
+
+  it('should be retryable for server errors', () => {
+    const error = new RegistrarApiError('porkbun', 'Server error', 503);
+
+    expect(error.retryable).toBe(true);
+    expect(error.statusCode).toBe(503);
+  });
+
+  it('should not be retryable for client errors', () => {
+    const error = new RegistrarApiError('porkbun', 'Bad request', 400);
+
+    expect(error.retryable).toBe(false);
+    expect(error.statusCode).toBe(400);
+  });
+});
+
+describe('AuthenticationError', () => {
+  it('should create with registrar name', () => {
+    const error = new AuthenticationError('porkbun');
+
+    expect(error.code).toBe('AUTH_ERROR');
+    expect(error.message).toContain('porkbun');
+    expect(error.suggestedAction).toContain('PORKBUN_API_KEY');
+  });
+});
+
+describe('NoSourceAvailableError', () => {
+  it('should list tried sources', () => {
+    const error = new NoSourceAvailableError('example.com', [
+      'porkbun',
+      'rdap',
+      'whois',
+    ]);
+
+    expect(error.code).toBe('NO_SOURCE_AVAILABLE');
+    expect(error.message).toContain('porkbun');
+    expect(error.message).toContain('rdap');
+    expect(error.message).toContain('whois');
+    expect(error.retryable).toBe(true);
+  });
+});
+
+describe('TimeoutError', () => {
+  it('should include operation and timeout', () => {
+    const error = new TimeoutError('API call', 5000);
+
+    expect(error.code).toBe('TIMEOUT');
+    expect(error.message).toContain('API call');
+    expect(error.message).toContain('5000');
+    expect(error.retryable).toBe(true);
+  });
+});
+
+describe('ConfigurationError', () => {
+  it('should include missing config and fix', () => {
+    const error = new ConfigurationError('API_KEY', 'Add it to .env file');
+
+    expect(error.code).toBe('CONFIG_ERROR');
+    expect(error.message).toContain('API_KEY');
+    expect(error.suggestedAction).toBe('Add it to .env file');
+    expect(error.retryable).toBe(false);
+  });
+});
+
+describe('wrapError', () => {
+  it('should return DomainSearchError as-is', () => {
+    const original = new InvalidDomainError('test', 'reason');
+    const wrapped = wrapError(original);
+
+    expect(wrapped).toBe(original);
+  });
+
+  it('should wrap regular Error', () => {
+    const original = new Error('Something failed');
+    const wrapped = wrapError(original);
+
+    expect(wrapped).toBeInstanceOf(DomainSearchError);
+    expect(wrapped.code).toBe('UNKNOWN_ERROR');
+    expect(wrapped.message).toBe('Something failed');
+  });
+
+  it('should wrap string errors', () => {
+    const wrapped = wrapError('String error');
+
+    expect(wrapped).toBeInstanceOf(DomainSearchError);
+    expect(wrapped.message).toBe('String error');
+  });
+});

package/tests/unit/tld-info.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Unit Tests for TLD Info Tool.
+ */
+
+import { executeTldInfo } from '../../src/tools/tld_info';
+
+describe('executeTldInfo', () => {
+  it('should return info for common TLDs', async () => {
+    const result = await executeTldInfo({ tld: 'com', detailed: false });
+
+    expect(result.tld).toBe('com');
+    expect(result.description).toContain('Commercial');
+    expect(result.popularity).toBe('high');
+    expect(result.category).toBe('generic');
+    expect(result.price_range).toBeDefined();
+    expect(result.insights).toBeInstanceOf(Array);
+    expect(result.recommendation).toBeDefined();
+  });
+
+  it('should return info for tech TLDs', async () => {
+    const result = await executeTldInfo({ tld: 'io', detailed: false });
+
+    expect(result.tld).toBe('io');
+    expect(result.description).toContain('tech');
+    expect(result.popularity).toBe('high');
+  });
+
+  it('should return info for dev TLD with restrictions', async () => {
+    const result = await executeTldInfo({ tld: 'dev', detailed: false });
+
+    expect(result.tld).toBe('dev');
+    expect(result.restrictions).toContain('Requires HTTPS (HSTS preloaded)');
+  });
+
+  it('should normalize TLD input', async () => {
+    const result = await executeTldInfo({ tld: '.COM', detailed: false });
+
+    expect(result.tld).toBe('com');
+  });
+
+  it('should return generic info for unknown TLDs', async () => {
+    const result = await executeTldInfo({ tld: 'xyz', detailed: false });
+
+    expect(result.tld).toBe('xyz');
+    expect(result.insights).toBeInstanceOf(Array);
+  });
+
+  it('should include price insights for cheap TLDs', async () => {
+    const result = await executeTldInfo({ tld: 'xyz', detailed: false });
+
+    const hasPriceInsight = result.insights.some((i) =>
+      i.includes('Budget') || i.includes('$'),
+    );
+    expect(hasPriceInsight).toBe(true);
+  });
+
+  it('should include recommendations', async () => {
+    const result = await executeTldInfo({ tld: 'ai', detailed: false });
+
+    expect(result.recommendation).toContain('AI');
+  });
+});