@newpeak/barista-cli 0.1.1 → 0.1.2

package/tests/unit/config.test.ts

@@ -1,141 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-// Mock dependencies before importing ConfigManager
-vi.mock('fs');
-vi.mock('os');
-vi.mock('yaml');
-
-describe('ConfigManager', () => {
-  const mockConfig = {
-    defaults: {
-      env: 'dev',
-      tenant: 'test-tenant',
-      service: 'liberica',
-    },
-    environments: {
-      dev: {
-        liberica: { baseUrl: 'https://{tenant}-dev.newpeaksh.com', timeout: 30000 },
-        arabica: { baseUrl: 'https://arabica-dev.newpeaksh.com', timeout: 30000 },
-      },
-      test: {
-        liberica: { baseUrl: 'https://{tenant}-test.newpeaksh.com', timeout: 30000 },
-        arabica: { baseUrl: 'https://arabica-test.newpeaksh.com', timeout: 30000 },
-      },
-      'prod-cn': {
-        liberica: { baseUrl: 'https://{tenant}.newpeaksh.com', timeout: 60000 },
-        arabica: { baseUrl: 'https://www.newpeaksh.com', timeout: 60000 },
-      },
-      'prod-jp': {
-        liberica: { baseUrl: 'https://{tenant}.newpeakjp.com', timeout: 60000 },
-        arabica: { baseUrl: 'https://members.newpeakjp.com', timeout: 60000 },
-      },
-    },
-    output: {
-      format: 'table',
-      color: true,
-      timestamp: true,
-    },
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
-
-  describe('getCurrentContext', () => {
-    it('should return current context with default values', () => {
-      // This test verifies the interface
-      const context = {
-        environment: 'dev' as const,
-        service: 'liberica' as const,
-        tenant: 'test-tenant',
-      };
-
-      expect(context.environment).toBe('dev');
-      expect(context.service).toBe('liberica');
-      expect(context.tenant).toBe('test-tenant');
-    });
-
-    it('should have correct environment values', () => {
-      const environments = ['dev', 'test', 'prod-cn', 'prod-jp'] as const;
-      environments.forEach((env) => {
-        expect(['dev', 'test', 'prod-cn', 'prod-jp']).toContain(env);
-      });
-    });
-  });
-
-  describe('setEnvironment', () => {
-    it('should validate environment values', () => {
-      const validEnvironments = ['dev', 'test', 'prod-cn', 'prod-jp'];
-      const invalidEnvironment = 'invalid-env';
-
-      expect(validEnvironments.includes('dev')).toBe(true);
-      expect(validEnvironments.includes(invalidEnvironment)).toBe(false);
-    });
-  });
-
-  describe('setTenant', () => {
-    it('should accept any non-empty string as tenant', () => {
-      const validTenant = 'my-tenant';
-      const emptyTenant = '';
-
-      expect(validTenant.length > 0).toBe(true);
-      expect(emptyTenant.length > 0).toBe(false);
-    });
-  });
-
-  describe('config structure', () => {
-    it('should have all required environment configurations', () => {
-      const envNames = Object.keys(mockConfig.environments);
-      expect(envNames).toContain('dev');
-      expect(envNames).toContain('test');
-      expect(envNames).toContain('prod-cn');
-      expect(envNames).toContain('prod-jp');
-    });
-
-    it('should have correct service URLs for each environment', () => {
-      const devConfig = mockConfig.environments.dev;
-      expect(devConfig.liberica.baseUrl).toContain('{tenant}-dev.newpeaksh.com');
-      expect(devConfig.arabica.baseUrl).toContain('arabica-dev.newpeaksh.com');
-    });
-
-    it('should have output configuration', () => {
-      expect(mockConfig.output.format).toBe('table');
-      expect(typeof mockConfig.output.color).toBe('boolean');
-      expect(typeof mockConfig.output.timestamp).toBe('boolean');
-    });
-  });
-
-  describe('getEnvironmentUrl', () => {
-    it('should build correct URL with tenant placeholder', () => {
-      const urlTemplate = 'https://{tenant}-dev.newpeaksh.com';
-      const tenant = 'mytenant';
-      const result = urlTemplate.replace('{tenant}', tenant);
-
-      expect(result).toBe('https://mytenant-dev.newpeaksh.com');
-    });
-
-    it('should return arabica URL without tenant substitution', () => {
-      const arabicaUrl = 'https://arabica-dev.newpeaksh.com';
-      // Arabica doesn't use tenant in URL
-      expect(arabicaUrl).not.toContain('{tenant}');
-    });
-  });
-});
-
-describe('Context interface', () => {
-  it('should have required properties', () => {
-    const context = {
-      environment: 'dev' as const,
-      service: 'liberica' as const,
-      tenant: 'electionjp',
-    };
-
-    expect(context).toHaveProperty('environment');
-    expect(context).toHaveProperty('service');
-    expect(context).toHaveProperty('tenant');
-  });
-});

package/tests/unit/types.test.ts

@@ -1,195 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { APIResponse, CommandOptions, Context, Config, TokenContext, Environment, Service } from '../../src/types/index.js';
-
-describe('APIResponse interface', () => {
-  it('should accept valid success response', () => {
-    const response: APIResponse = {
-      success: true,
-      data: { id: '123', name: 'Test' },
-      meta: {
-        requestId: 'req-001',
-        timestamp: '2024-01-15T10:30:00Z',
-        pagination: {
-          page: 1,
-          size: 20,
-          total: 100,
-          totalPages: 5,
-        },
-      },
-    };
-
-    expect(response.success).toBe(true);
-    expect(response.data).toBeDefined();
-    expect(response.meta?.pagination?.page).toBe(1);
-  });
-
-  it('should accept valid error response', () => {
-    const response: APIResponse = {
-      success: false,
-      error: {
-        code: 'NOT_FOUND',
-        message: 'Resource not found',
-        details: { resourceId: '123' },
-      },
-    };
-
-    expect(response.success).toBe(false);
-    expect(response.error?.code).toBe('NOT_FOUND');
-    expect(response.error?.message).toBe('Resource not found');
-  });
-
-  it('should allow data to be undefined', () => {
-    const response: APIResponse = {
-      success: true,
-    };
-
-    expect(response.data).toBeUndefined();
-  });
-
-  it('should support generic type parameter', () => {
-    interface Order {
-      id: string;
-      productName: string;
-      quantity: number;
-    }
-
-    const response: APIResponse<Order[]> = {
-      success: true,
-      data: [
-        { id: '1', productName: 'Coffee Machine', quantity: 10 },
-        { id: '2', productName: 'Grinder', quantity: 5 },
-      ],
-    };
-
-    expect(response.data).toHaveLength(2);
-    expect(response.data?.[0].productName).toBe('Coffee Machine');
-  });
-});
-
-describe('CommandOptions interface', () => {
-  it('should accept all optional command options', () => {
-    const options: CommandOptions = {
-      env: 'dev',
-      tenant: 'electionjp',
-      dryRun: true,
-      json: false,
-      debug: true,
-    };
-
-    expect(options.env).toBe('dev');
-    expect(options.tenant).toBe('electionjp');
-    expect(options.dryRun).toBe(true);
-    expect(options.json).toBe(false);
-    expect(options.debug).toBe(true);
-  });
-
-  it('should allow partial options', () => {
-    const options: CommandOptions = {
-      env: 'prod-cn',
-    };
-
-    expect(options.env).toBe('prod-cn');
-    expect(options.tenant).toBeUndefined();
-    expect(options.dryRun).toBeUndefined();
-  });
-});
-
-describe('Context interface', () => {
-  it('should have correct structure', () => {
-    const context: Context = {
-      environment: 'test',
-      service: 'arabica',
-      tenant: 'my-tenant',
-    };
-
-    expect(context.environment).toBe('test');
-    expect(context.service).toBe('arabica');
-    expect(context.tenant).toBe('my-tenant');
-  });
-});
-
-describe('Environment type', () => {
-  it('should accept valid environment values', () => {
-    const envs: Environment[] = ['dev', 'test', 'prod-cn', 'prod-jp'];
-
-    envs.forEach((env) => {
-      const context: Context = { environment: env, service: 'liberica', tenant: 't' };
-      expect(context.environment).toBe(env);
-    });
-  });
-});
-
-describe('Service type', () => {
-  it('should accept valid service values', () => {
-    const services: Service[] = ['liberica', 'arabica'];
-
-    services.forEach((service) => {
-      const context: Context = { environment: 'dev', service, tenant: 't' };
-      expect(context.service).toBe(service);
-    });
-  });
-});
-
-describe('Config interface', () => {
-  it('should have defaults structure', () => {
-    const config: Config = {
-      defaults: {
-        env: 'dev',
-        tenant: 'default',
-        service: 'liberica',
-      },
-      environments: {
-        dev: {
-          liberica: { baseUrl: 'https://dev.example.com', timeout: 30000 },
-          arabica: { baseUrl: 'https://arabica-dev.example.com', timeout: 30000 },
-        },
-        test: {
-          liberica: { baseUrl: 'https://test.example.com', timeout: 30000 },
-          arabica: { baseUrl: 'https://arabica-test.example.com', timeout: 30000 },
-        },
-        'prod-cn': {
-          liberica: { baseUrl: 'https://example.com', timeout: 60000 },
-          arabica: { baseUrl: 'https://www.example.com', timeout: 60000 },
-        },
-        'prod-jp': {
-          liberica: { baseUrl: 'https://example.jp', timeout: 60000 },
-          arabica: { baseUrl: 'https://members.example.jp', timeout: 60000 },
-        },
-      },
-      output: {
-        format: 'table',
-        color: true,
-        timestamp: true,
-      },
-    };
-
-    expect(config.defaults.env).toBe('dev');
-    expect(config.defaults.tenant).toBe('default');
-    expect(config.environments.dev.liberica.baseUrl).toContain('dev.example.com');
-  });
-});
-
-describe('TokenContext interface', () => {
-  it('should accept valid token context without tenant', () => {
-    const context: TokenContext = {
-      service: 'arabica',
-      environment: 'dev',
-    };
-
-    expect(context.service).toBe('arabica');
-    expect(context.environment).toBe('dev');
-    expect(context.tenant).toBeUndefined();
-  });
-
-  it('should accept valid token context with tenant', () => {
-    const context: TokenContext = {
-      service: 'liberica',
-      environment: 'prod-cn',
-      tenant: 'electionjp',
-    };
-
-    expect(context.service).toBe('liberica');
-    expect(context.environment).toBe('prod-cn');
-    expect(context.tenant).toBe('electionjp');
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}