@newpeak/barista-cli 0.1.0

package/tests/unit/config.test.ts

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,195 @@
+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

@@ -0,0 +1,20 @@
+{
+  "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"]
+}