mcp-rubber-duck 1.5.2 → 1.6.1

package/src/tools/get-usage-stats.ts

@@ -0,0 +1,109 @@
+import { UsageService } from '../services/usage.js';
+import { UsageTimePeriod } from '../config/types.js';
+import { duckArt } from '../utils/ascii-art.js';
+import { logger } from '../utils/logger.js';
+
+const VALID_PERIODS: UsageTimePeriod[] = ['today', '7d', '30d', 'all'];
+
+export function getUsageStatsTool(
+  usageService: UsageService,
+  args: Record<string, unknown>
+) {
+  const { period = 'today' } = args as { period?: string };
+
+  // Validate period
+  if (!VALID_PERIODS.includes(period as UsageTimePeriod)) {
+    throw new Error(`Invalid period "${period}". Valid options: ${VALID_PERIODS.join(', ')}`);
+  }
+
+  const stats = usageService.getStats(period as UsageTimePeriod);
+
+  // Format output
+  let output = `${duckArt.panel}\n\n`;
+  output += `📊 Usage Statistics: ${formatPeriodLabel(period as UsageTimePeriod)}\n`;
+  output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+  output += `Period: ${stats.startDate} to ${stats.endDate}\n\n`;
+
+  // Totals section
+  output += `📈 TOTALS\n`;
+  output += `─────────────────────\n`;
+  output += `Requests: ${stats.totals.requests.toLocaleString()}\n`;
+  output += `Prompt Tokens: ${stats.totals.promptTokens.toLocaleString()}\n`;
+  output += `Completion Tokens: ${stats.totals.completionTokens.toLocaleString()}\n`;
+  output += `Total Tokens: ${(stats.totals.promptTokens + stats.totals.completionTokens).toLocaleString()}\n`;
+  output += `Cache Hits: ${stats.totals.cacheHits.toLocaleString()}\n`;
+  output += `Errors: ${stats.totals.errors.toLocaleString()}\n`;
+
+  if (stats.totals.estimatedCostUSD !== undefined) {
+    output += `💰 Estimated Cost: $${formatCost(stats.totals.estimatedCostUSD)} USD\n`;
+  }
+
+  // Per-provider breakdown
+  const providers = Object.keys(stats.usage);
+  if (providers.length > 0) {
+    output += `\n🦆 BY PROVIDER\n`;
+    output += `─────────────────────\n`;
+
+    for (const provider of providers) {
+      const models = stats.usage[provider];
+      output += `\n**${provider}**\n`;
+
+      for (const [model, modelStats] of Object.entries(models)) {
+        output += `  ${model}:\n`;
+        output += `    Requests: ${modelStats.requests.toLocaleString()}\n`;
+        output += `    Tokens: ${modelStats.promptTokens.toLocaleString()} in / ${modelStats.completionTokens.toLocaleString()} out\n`;
+        if (modelStats.cacheHits > 0) {
+          output += `    Cache Hits: ${modelStats.cacheHits.toLocaleString()}\n`;
+        }
+        if (modelStats.errors > 0) {
+          output += `    Errors: ${modelStats.errors.toLocaleString()}\n`;
+        }
+      }
+
+      if (stats.costByProvider && stats.costByProvider[provider] !== undefined) {
+        output += `  💰 Provider Cost: $${formatCost(stats.costByProvider[provider])}\n`;
+      }
+    }
+  } else {
+    output += `\nNo usage data for this period.\n`;
+  }
+
+  // Footer note about cost
+  if (stats.totals.estimatedCostUSD === undefined && stats.totals.requests > 0) {
+    output += `\n💡 Cost estimates not available. Configure pricing in config.json or update to latest version.\n`;
+  }
+
+  logger.info(`Retrieved usage stats for period: ${period}`);
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: output,
+      },
+    ],
+  };
+}
+
+function formatPeriodLabel(period: UsageTimePeriod): string {
+  switch (period) {
+    case 'today':
+      return 'Today';
+    case '7d':
+      return 'Last 7 Days';
+    case '30d':
+      return 'Last 30 Days';
+    case 'all':
+      return 'All Time';
+  }
+}
+
+function formatCost(cost: number): string {
+  if (cost < 0.01) {
+    return cost.toFixed(6);
+  } else if (cost < 1) {
+    return cost.toFixed(4);
+  } else {
+    return cost.toFixed(2);
+  }
+}

package/tests/pricing.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { PricingService } from '../src/services/pricing.js';
+import { PricingConfig } from '../src/config/types.js';
+import { DEFAULT_PRICING } from '../src/data/default-pricing.js';
+
+describe('PricingService', () => {
+  describe('default pricing', () => {
+    let service: PricingService;
+
+    beforeEach(() => {
+      service = new PricingService();
+    });
+
+    it('should load default pricing when no config override', () => {
+      // Check a known default price
+      const pricing = service.getPricing('openai', 'gpt-4o');
+      expect(pricing).toBeDefined();
+      expect(pricing?.inputPricePerMillion).toBe(2.5);
+      expect(pricing?.outputPricePerMillion).toBe(10);
+    });
+
+    it('should have pricing for common providers', () => {
+      expect(service.getPricing('openai', 'gpt-4o')).toBeDefined();
+      expect(service.getPricing('anthropic', 'claude-3-5-sonnet-20241022')).toBeDefined();
+      expect(service.getPricing('google', 'gemini-1.5-pro')).toBeDefined();
+      expect(service.getPricing('groq', 'llama-3.3-70b-versatile')).toBeDefined();
+    });
+
+    it('should return undefined for unknown provider', () => {
+      expect(service.getPricing('unknown-provider', 'some-model')).toBeUndefined();
+    });
+
+    it('should return undefined for unknown model', () => {
+      expect(service.getPricing('openai', 'unknown-model')).toBeUndefined();
+    });
+
+    it('should list all providers', () => {
+      const providers = service.getProviders();
+      expect(providers).toContain('openai');
+      expect(providers).toContain('anthropic');
+      expect(providers).toContain('google');
+      expect(providers).toContain('groq');
+    });
+
+    it('should list models for a provider', () => {
+      const models = service.getModelsForProvider('openai');
+      expect(models).toContain('gpt-4o');
+      expect(models).toContain('gpt-4o-mini');
+    });
+
+    it('should return empty array for unknown provider models', () => {
+      const models = service.getModelsForProvider('unknown-provider');
+      expect(models).toEqual([]);
+    });
+  });
+
+  describe('config overrides', () => {
+    it('should override default pricing with config values', () => {
+      const configPricing: PricingConfig = {
+        openai: {
+          'gpt-4o': { inputPricePerMillion: 100, outputPricePerMillion: 200 },
+        },
+      };
+
+      const service = new PricingService(configPricing);
+      const pricing = service.getPricing('openai', 'gpt-4o');
+
+      expect(pricing?.inputPricePerMillion).toBe(100);
+      expect(pricing?.outputPricePerMillion).toBe(200);
+    });
+
+    it('should add new providers from config', () => {
+      const configPricing: PricingConfig = {
+        'my-custom-provider': {
+          'custom-model': { inputPricePerMillion: 1, outputPricePerMillion: 2 },
+        },
+      };
+
+      const service = new PricingService(configPricing);
+      const pricing = service.getPricing('my-custom-provider', 'custom-model');
+
+      expect(pricing?.inputPricePerMillion).toBe(1);
+      expect(pricing?.outputPricePerMillion).toBe(2);
+    });
+
+    it('should add new models to existing providers', () => {
+      const configPricing: PricingConfig = {
+        openai: {
+          'new-custom-model': { inputPricePerMillion: 5, outputPricePerMillion: 10 },
+        },
+      };
+
+      const service = new PricingService(configPricing);
+
+      // New model should exist
+      const newPricing = service.getPricing('openai', 'new-custom-model');
+      expect(newPricing?.inputPricePerMillion).toBe(5);
+
+      // Existing default models should still exist
+      const existingPricing = service.getPricing('openai', 'gpt-4o-mini');
+      expect(existingPricing).toBeDefined();
+    });
+
+    it('should preserve default providers when config adds new ones', () => {
+      const configPricing: PricingConfig = {
+        'new-provider': {
+          'new-model': { inputPricePerMillion: 1, outputPricePerMillion: 2 },
+        },
+      };
+
+      const service = new PricingService(configPricing);
+
+      // New provider should exist
+      expect(service.getPricing('new-provider', 'new-model')).toBeDefined();
+
+      // Default providers should still exist
+      expect(service.getPricing('openai', 'gpt-4o')).toBeDefined();
+      expect(service.getPricing('anthropic', 'claude-3-5-sonnet-20241022')).toBeDefined();
+    });
+
+    it('should handle empty config override object', () => {
+      const service = new PricingService({});
+
+      // Default providers should still exist
+      expect(service.getPricing('openai', 'gpt-4o')).toBeDefined();
+      expect(service.getProviders().length).toBeGreaterThan(0);
+    });
+
+    it('should be case-sensitive for provider and model names', () => {
+      const service = new PricingService();
+
+      // Exact case should work
+      expect(service.getPricing('openai', 'gpt-4o')).toBeDefined();
+
+      // Different case should NOT work
+      expect(service.getPricing('OpenAI', 'gpt-4o')).toBeUndefined();
+      expect(service.getPricing('openai', 'GPT-4o')).toBeUndefined();
+      expect(service.getPricing('OPENAI', 'GPT-4O')).toBeUndefined();
+    });
+  });
+
+  describe('cost calculation', () => {
+    let service: PricingService;
+
+    beforeEach(() => {
+      service = new PricingService({
+        test: {
+          'test-model': { inputPricePerMillion: 5, outputPricePerMillion: 15 },
+        },
+      });
+    });
+
+    it('should calculate cost correctly', () => {
+      // 500 prompt tokens at $5/M = $0.0025
+      // 200 completion tokens at $15/M = $0.003
+      // Total = $0.0055
+      const cost = service.calculateCost('test', 'test-model', 500, 200);
+
+      expect(cost).not.toBeNull();
+      expect(cost?.inputCost).toBeCloseTo(0.0025, 6);
+      expect(cost?.outputCost).toBeCloseTo(0.003, 6);
+      expect(cost?.totalCost).toBeCloseTo(0.0055, 6);
+    });
+
+    it('should return null for unknown provider', () => {
+      const cost = service.calculateCost('unknown', 'model', 1000, 1000);
+      expect(cost).toBeNull();
+    });
+
+    it('should return null for unknown model', () => {
+      const cost = service.calculateCost('test', 'unknown-model', 1000, 1000);
+      expect(cost).toBeNull();
+    });
+
+    it('should return zero cost for zero tokens', () => {
+      const cost = service.calculateCost('test', 'test-model', 0, 0);
+
+      expect(cost).not.toBeNull();
+      expect(cost?.inputCost).toBe(0);
+      expect(cost?.outputCost).toBe(0);
+      expect(cost?.totalCost).toBe(0);
+    });
+
+    it('should handle large token counts', () => {
+      // 1 million tokens at $5/M = $5
+      const cost = service.calculateCost('test', 'test-model', 1_000_000, 1_000_000);
+
+      expect(cost).not.toBeNull();
+      expect(cost?.inputCost).toBe(5);
+      expect(cost?.outputCost).toBe(15);
+      expect(cost?.totalCost).toBe(20);
+    });
+
+    it('should handle fractional prices correctly', () => {
+      const serviceWithFractional = new PricingService({
+        test: {
+          'cheap-model': { inputPricePerMillion: 0.15, outputPricePerMillion: 0.6 },
+        },
+      });
+
+      // 1000 tokens at $0.15/M = $0.00015
+      const cost = serviceWithFractional.calculateCost('test', 'cheap-model', 1000, 1000);
+
+      expect(cost).not.toBeNull();
+      expect(cost?.inputCost).toBeCloseTo(0.00015, 8);
+      expect(cost?.outputCost).toBeCloseTo(0.0006, 8);
+    });
+
+    it('should calculate cost for free models as zero', () => {
+      const serviceWithFree = new PricingService({
+        test: {
+          'free-model': { inputPricePerMillion: 0, outputPricePerMillion: 0 },
+        },
+      });
+
+      const cost = serviceWithFree.calculateCost('test', 'free-model', 10000, 5000);
+
+      expect(cost).not.toBeNull();
+      expect(cost?.totalCost).toBe(0);
+    });
+  });
+
+  describe('hasPricingFor', () => {
+    let service: PricingService;
+
+    beforeEach(() => {
+      service = new PricingService();
+    });
+
+    it('should return true for known provider/model', () => {
+      expect(service.hasPricingFor('openai', 'gpt-4o')).toBe(true);
+    });
+
+    it('should return false for unknown provider', () => {
+      expect(service.hasPricingFor('unknown', 'gpt-4o')).toBe(false);
+    });
+
+    it('should return false for unknown model', () => {
+      expect(service.hasPricingFor('openai', 'unknown-model')).toBe(false);
+    });
+  });
+
+  describe('provider aliases', () => {
+    let service: PricingService;
+
+    beforeEach(() => {
+      service = new PricingService();
+    });
+
+    it('should resolve "gemini" to "google" pricing', () => {
+      const pricing = service.getPricing('gemini', 'gemini-2.5-flash');
+      expect(pricing).toBeDefined();
+      expect(pricing?.inputPricePerMillion).toBe(0.3);
+      expect(pricing?.outputPricePerMillion).toBe(2.5);
+    });
+
+    it('should still work with canonical "google" provider name', () => {
+      const pricing = service.getPricing('google', 'gemini-2.5-flash');
+      expect(pricing).toBeDefined();
+      expect(pricing?.inputPricePerMillion).toBe(0.3);
+    });
+
+    it('should calculate cost with aliased provider', () => {
+      const cost = service.calculateCost('gemini', 'gemini-2.5-flash', 1_000_000, 1_000_000);
+      expect(cost).not.toBeNull();
+      expect(cost?.inputCost).toBe(0.3);
+      expect(cost?.outputCost).toBe(2.5);
+    });
+
+    it('should return true for hasPricingFor with aliased provider', () => {
+      expect(service.hasPricingFor('gemini', 'gemini-2.5-flash')).toBe(true);
+    });
+
+    it('should list models for aliased provider', () => {
+      const models = service.getModelsForProvider('gemini');
+      expect(models).toContain('gemini-2.5-flash');
+      expect(models).toContain('gemini-1.5-pro');
+    });
+
+    it('should prefer direct provider match over alias', () => {
+      // If user adds "gemini" in their config, it should take precedence
+      const configPricing: PricingConfig = {
+        gemini: {
+          'custom-gemini-model': { inputPricePerMillion: 99, outputPricePerMillion: 199 },
+        },
+      };
+      const serviceWithOverride = new PricingService(configPricing);
+
+      // Custom model should work
+      const customPricing = serviceWithOverride.getPricing('gemini', 'custom-gemini-model');
+      expect(customPricing?.inputPricePerMillion).toBe(99);
+
+      // But google models won't be accessible via "gemini" anymore since direct match wins
+      const googlePricing = serviceWithOverride.getPricing('gemini', 'gemini-2.5-flash');
+      expect(googlePricing).toBeUndefined();
+
+      // Google models still accessible via "google"
+      const directPricing = serviceWithOverride.getPricing('google', 'gemini-2.5-flash');
+      expect(directPricing).toBeDefined();
+    });
+  });
+
+  describe('getAllPricing', () => {
+    it('should return all pricing data', () => {
+      const service = new PricingService();
+      const allPricing = service.getAllPricing();
+
+      expect(allPricing).toHaveProperty('openai');
+      expect(allPricing).toHaveProperty('anthropic');
+      expect(allPricing.openai).toHaveProperty('gpt-4o');
+    });
+
+    it('should return a copy, not the original', () => {
+      const service = new PricingService();
+      const pricing1 = service.getAllPricing();
+      const pricing2 = service.getAllPricing();
+
+      expect(pricing1).not.toBe(pricing2);
+    });
+
+    it('should return a deep copy (mutations do not affect original)', () => {
+      const service = new PricingService();
+      const pricing = service.getAllPricing();
+
+      // Store original values
+      const originalInput = service.getPricing('openai', 'gpt-4o')?.inputPricePerMillion;
+
+      // Mutate the copy
+      pricing.openai['gpt-4o'].inputPricePerMillion = 999;
+
+      // Original should be unchanged
+      expect(service.getPricing('openai', 'gpt-4o')?.inputPricePerMillion).toBe(originalInput);
+    });
+  });
+});

package/tests/tools/get-usage-stats.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { getUsageStatsTool } from '../../src/tools/get-usage-stats.js';
+import { UsageService } from '../../src/services/usage.js';
+import { PricingService } from '../../src/services/pricing.js';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../../src/utils/logger');
+
+describe('getUsageStatsTool', () => {
+  let tempDir: string;
+  let pricingService: PricingService;
+  let usageService: UsageService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'usage-tool-test-'));
+
+    pricingService = new PricingService({
+      testprovider: {
+        'test-model': { inputPricePerMillion: 5, outputPricePerMillion: 15 },
+      },
+    });
+
+    usageService = new UsageService(pricingService, {
+      dataDir: tempDir,
+      debounceMs: 0,
+    });
+  });
+
+  afterEach(() => {
+    usageService.shutdown();
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  describe('input validation', () => {
+    it('should throw error for invalid period', () => {
+      expect(() => {
+        getUsageStatsTool(usageService, { period: 'invalid' });
+      }).toThrow('Invalid period "invalid"');
+    });
+
+    it('should accept valid periods', () => {
+      expect(() => getUsageStatsTool(usageService, { period: 'today' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: '7d' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: '30d' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: 'all' })).not.toThrow();
+    });
+
+    it('should default to today when period not specified', () => {
+      const result = getUsageStatsTool(usageService, {});
+
+      expect(result.content[0].text).toContain('Today');
+    });
+  });
+
+  describe('output format', () => {
+    it('should return MCP-compliant response', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+
+      expect(result.content).toBeDefined();
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0].type).toBe('text');
+      expect(typeof result.content[0].text).toBe('string');
+    });
+
+    it('should include period label in output', () => {
+      const result = getUsageStatsTool(usageService, { period: '7d' });
+      expect(result.content[0].text).toContain('Last 7 Days');
+    });
+
+    it('should include date range', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      // Should contain dates in YYYY-MM-DD format
+      expect(result.content[0].text).toMatch(/\d{4}-\d{2}-\d{2}/);
+    });
+
+    it('should include totals section', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('TOTALS');
+      expect(text).toContain('Requests:');
+      expect(text).toContain('Prompt Tokens:');
+      expect(text).toContain('Completion Tokens:');
+    });
+
+    it('should include per-provider breakdown', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+      usageService.recordUsage('anthropic', 'claude-3', 200, 100, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('BY PROVIDER');
+      expect(text).toContain('openai');
+      expect(text).toContain('anthropic');
+      expect(text).toContain('gpt-4o');
+      expect(text).toContain('claude-3');
+    });
+
+    it('should show cost when pricing available', () => {
+      usageService.recordUsage('testprovider', 'test-model', 1000, 500, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Estimated Cost:');
+      expect(text).toContain('$');
+      expect(text).toContain('USD');
+    });
+
+    it('should show hint when cost unavailable', () => {
+      usageService.recordUsage('unknown-provider', 'unknown-model', 1000, 500, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Cost estimates not available');
+    });
+
+    it('should handle empty usage gracefully', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('No usage data');
+    });
+
+    it('should show cache hits when present', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, true, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Cache Hits:');
+    });
+
+    it('should show errors when present', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 0, 0, false, true);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Errors:');
+    });
+  });
+
+  describe('period filtering', () => {
+    it('should filter data by period', () => {
+      // Record some usage for today
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+      // Today should have data
+      const todayResult = getUsageStatsTool(usageService, { period: 'today' });
+      expect(todayResult.content[0].text).toContain('Requests: 1');
+
+      // All should also have data
+      const allResult = getUsageStatsTool(usageService, { period: 'all' });
+      expect(allResult.content[0].text).toContain('Requests: 1');
+    });
+  });
+
+  describe('formatting', () => {
+    it('should format large numbers with commas', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 1000000, 500000, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should have formatted numbers
+      expect(text).toContain('1,000,000');
+    });
+
+    it('should format cost with appropriate precision', () => {
+      // Small cost
+      usageService.recordUsage('testprovider', 'test-model', 100, 50, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show cost with decimal places
+      expect(text).toMatch(/\$\d+\.\d+/);
+    });
+
+    it('should format very small costs with 6 decimal places', () => {
+      // Very small cost (10 tokens at $5/M = $0.00005)
+      usageService.recordUsage('testprovider', 'test-model', 10, 0, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show 6 decimal places for very small amounts
+      expect(text).toMatch(/\$0\.0000\d+/);
+    });
+
+    it('should format large costs with 2 decimal places', () => {
+      // Large cost (10M tokens at $5/M = $50)
+      usageService.recordUsage('testprovider', 'test-model', 10000000, 0, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show 2 decimal places for larger amounts
+      expect(text).toMatch(/\$\d+\.\d{2}\s*USD/);
+    });
+
+    it('should show $0 cost for free models', () => {
+      // Create service with free pricing
+      const freePricingService = new PricingService({
+        freeprovider: {
+          'free-model': { inputPricePerMillion: 0, outputPricePerMillion: 0 },
+        },
+      });
+      const freeUsageService = new UsageService(freePricingService, {
+        dataDir: tempDir,
+        debounceMs: 0,
+      });
+
+      freeUsageService.recordUsage('freeprovider', 'free-model', 1000000, 500000, false, false);
+
+      const result = getUsageStatsTool(freeUsageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show $0 cost
+      expect(text).toContain('$0');
+      expect(text).toContain('Estimated Cost:');
+
+      freeUsageService.shutdown();
+    });
+  });
+});