Add unit tests for remote API commands and utilities

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/205a6eab-27f7-46cf-aee8-b628c23b3490

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Claude

packages/cli/test/remote-api-commands.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import AuthLogin from '../src/commands/auth/login';
+import AuthLogout from '../src/commands/auth/logout';
+import AuthWhoami from '../src/commands/auth/whoami';
+import DataQuery from '../src/commands/data/query';
+import DataGet from '../src/commands/data/get';
+import DataCreate from '../src/commands/data/create';
+import DataUpdate from '../src/commands/data/update';
+import DataDelete from '../src/commands/data/delete';
+import MetaList from '../src/commands/meta/list';
+import MetaGet from '../src/commands/meta/get';
+import MetaRegister from '../src/commands/meta/register';
+import MetaDelete from '../src/commands/meta/delete';
+
+describe('Remote API Commands (oclif)', () => {
+  describe('Auth Commands', () => {
+    it('should have auth login command', () => {
+      expect(AuthLogin.description).toContain('Authenticate');
+      expect(AuthLogin.flags).toHaveProperty('url');
+      expect(AuthLogin.flags).toHaveProperty('email');
+      expect(AuthLogin.flags).toHaveProperty('password');
+      expect(AuthLogin.flags).toHaveProperty('json');
+    });
+
+    it('should have auth logout command', () => {
+      expect(AuthLogout.description).toContain('Clear');
+      expect(AuthLogout.flags).toHaveProperty('json');
+    });
+
+    it('should have auth whoami command', () => {
+      expect(AuthWhoami.description).toContain('session');
+      expect(AuthWhoami.flags).toHaveProperty('url');
+      expect(AuthWhoami.flags).toHaveProperty('token');
+      expect(AuthWhoami.flags).toHaveProperty('format');
+    });
+
+    it('auth commands should have examples', () => {
+      expect(AuthLogin.examples).toBeDefined();
+      expect(AuthLogin.examples.length).toBeGreaterThan(0);
+      expect(AuthLogout.examples).toBeDefined();
+      expect(AuthWhoami.examples).toBeDefined();
+    });
+  });
+
+  describe('Data Commands', () => {
+    it('should have data query command', () => {
+      expect(DataQuery.description).toContain('Query');
+      expect(DataQuery.args).toHaveProperty('object');
+      expect(DataQuery.flags).toHaveProperty('filter');
+      expect(DataQuery.flags).toHaveProperty('fields');
+      expect(DataQuery.flags).toHaveProperty('sort');
+      expect(DataQuery.flags).toHaveProperty('limit');
+      expect(DataQuery.flags).toHaveProperty('offset');
+      expect(DataQuery.flags).toHaveProperty('format');
+    });
+
+    it('should have data get command', () => {
+      expect(DataGet.description).toContain('single record');
+      expect(DataGet.args).toHaveProperty('object');
+      expect(DataGet.args).toHaveProperty('id');
+      expect(DataGet.flags).toHaveProperty('format');
+    });
+
+    it('should have data create command', () => {
+      expect(DataCreate.description).toContain('Create');
+      expect(DataCreate.args).toHaveProperty('object');
+      expect(DataCreate.flags).toHaveProperty('data');
+      expect(DataCreate.flags).toHaveProperty('format');
+    });
+
+    it('should have data update command', () => {
+      expect(DataUpdate.description).toContain('Update');
+      expect(DataUpdate.args).toHaveProperty('object');
+      expect(DataUpdate.args).toHaveProperty('id');
+      expect(DataUpdate.flags).toHaveProperty('data');
+      expect(DataUpdate.flags).toHaveProperty('format');
+    });
+
+    it('should have data delete command', () => {
+      expect(DataDelete.description).toContain('Delete');
+      expect(DataDelete.args).toHaveProperty('object');
+      expect(DataDelete.args).toHaveProperty('id');
+      expect(DataDelete.flags).toHaveProperty('format');
+    });
+
+    it('data commands should support common flags', () => {
+      const commands = [DataQuery, DataGet, DataCreate, DataUpdate, DataDelete];
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags).toHaveProperty('token');
+      });
+    });
+
+    it('data commands should have examples', () => {
+      expect(DataQuery.examples).toBeDefined();
+      expect(DataQuery.examples.length).toBeGreaterThan(0);
+      expect(DataGet.examples).toBeDefined();
+      expect(DataCreate.examples).toBeDefined();
+      expect(DataUpdate.examples).toBeDefined();
+      expect(DataDelete.examples).toBeDefined();
+    });
+  });
+
+  describe('Metadata Commands', () => {
+    it('should have meta list command', () => {
+      expect(MetaList.description).toContain('List metadata');
+      expect(MetaList.args).toHaveProperty('type');
+      expect(MetaList.flags).toHaveProperty('format');
+    });
+
+    it('should have meta get command', () => {
+      expect(MetaGet.description).toContain('Get');
+      expect(MetaGet.args).toHaveProperty('type');
+      expect(MetaGet.args).toHaveProperty('name');
+      expect(MetaGet.flags).toHaveProperty('format');
+    });
+
+    it('should have meta register command', () => {
+      expect(MetaRegister.description).toContain('Register');
+      expect(MetaRegister.args).toHaveProperty('type');
+      expect(MetaRegister.flags).toHaveProperty('data');
+      expect(MetaRegister.flags).toHaveProperty('format');
+    });
+
+    it('should have meta delete command', () => {
+      expect(MetaDelete.description).toContain('Delete');
+      expect(MetaDelete.args).toHaveProperty('type');
+      expect(MetaDelete.args).toHaveProperty('name');
+      expect(MetaDelete.flags).toHaveProperty('format');
+    });
+
+    it('meta commands should support common flags', () => {
+      const commands = [MetaList, MetaGet, MetaRegister, MetaDelete];
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags).toHaveProperty('token');
+      });
+    });
+
+    it('meta commands should have examples', () => {
+      expect(MetaList.examples).toBeDefined();
+      expect(MetaList.examples.length).toBeGreaterThan(0);
+      expect(MetaGet.examples).toBeDefined();
+      expect(MetaRegister.examples).toBeDefined();
+      expect(MetaDelete.examples).toBeDefined();
+    });
+  });
+
+  describe('Command Conventions', () => {
+    it('all remote commands should support --url flag with OBJECTSTACK_URL env var', () => {
+      const commands = [
+        AuthLogin, AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags.url).toHaveProperty('env', 'OBJECTSTACK_URL');
+      });
+    });
+
+    it('authenticated commands should support --token flag with OBJECTSTACK_TOKEN env var', () => {
+      const commands = [
+        AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('token');
+        expect(cmd.flags.token).toHaveProperty('env', 'OBJECTSTACK_TOKEN');
+      });
+    });
+
+    it('all commands should support output formatting', () => {
+      const commands = [
+        AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('format');
+      });
+    });
+  });
+});

packages/cli/test/remote-api-utils.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createApiClient, requireAuth } from '../src/utils/api-client';
+import { readAuthConfig, writeAuthConfig, deleteAuthConfig, getCredentialsPath } from '../src/utils/auth-config';
+import { formatOutput } from '../src/utils/output-formatter';
+import * as fs from 'node:fs/promises';
+
+// Mock fs module
+vi.mock('node:fs/promises');
+
+describe('API Client Utilities', () => {
+  describe('createApiClient', () => {
+    it('should use provided URL and token', async () => {
+      const client = await createApiClient({
+        url: 'https://test.example.com',
+        token: 'test-token',
+      });
+
+      expect(client).toBeDefined();
+      expect((client as any).baseUrl).toBe('https://test.example.com');
+      expect((client as any).token).toBe('test-token');
+    });
+
+    it('should default to localhost when no URL provided', async () => {
+      const client = await createApiClient({});
+
+      expect(client).toBeDefined();
+      expect((client as any).baseUrl).toBe('http://localhost:3000');
+    });
+
+    it('should use environment variables if no options provided', async () => {
+      const originalUrl = process.env.OBJECTSTACK_URL;
+      const originalToken = process.env.OBJECTSTACK_TOKEN;
+
+      process.env.OBJECTSTACK_URL = 'https://env.example.com';
+      process.env.OBJECTSTACK_TOKEN = 'env-token';
+
+      const client = await createApiClient({});
+
+      expect((client as any).baseUrl).toBe('https://env.example.com');
+      expect((client as any).token).toBe('env-token');
+
+      // Restore
+      process.env.OBJECTSTACK_URL = originalUrl;
+      process.env.OBJECTSTACK_TOKEN = originalToken;
+    });
+  });
+
+  describe('requireAuth', () => {
+    it('should not throw when token is provided', () => {
+      expect(() => requireAuth('valid-token')).not.toThrow();
+    });
+
+    it('should throw when token is missing', () => {
+      expect(() => requireAuth(undefined)).toThrow(/Authentication required/);
+    });
+
+    it('should throw when token is empty string', () => {
+      expect(() => requireAuth('')).toThrow(/Authentication required/);
+    });
+  });
+});
+
+describe('Auth Config Utilities', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getCredentialsPath', () => {
+    it('should return path to credentials file', () => {
+      const path = getCredentialsPath();
+      expect(path).toContain('.objectstack');
+      expect(path).toContain('credentials.json');
+    });
+  });
+
+  describe('writeAuthConfig', () => {
+    it('should write credentials to file with correct permissions', async () => {
+      const mockMkdir = vi.mocked(fs.mkdir);
+      const mockWriteFile = vi.mocked(fs.writeFile);
+
+      const config = {
+        url: 'https://test.example.com',
+        token: 'test-token',
+        email: 'user@example.com',
+        createdAt: '2024-01-01T00:00:00.000Z',
+      };
+
+      await writeAuthConfig(config);
+
+      expect(mockMkdir).toHaveBeenCalledWith(
+        expect.stringContaining('.objectstack'),
+        { recursive: true }
+      );
+
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        expect.stringContaining('credentials.json'),
+        expect.stringContaining('test-token'),
+        { mode: 0o600 }
+      );
+    });
+  });
+
+  describe('readAuthConfig', () => {
+    it('should read and parse credentials file', async () => {
+      const mockConfig = {
+        url: 'https://test.example.com',
+        token: 'test-token',
+        email: 'user@example.com',
+        createdAt: '2024-01-01T00:00:00.000Z',
+      };
+
+      const mockReadFile = vi.mocked(fs.readFile);
+      mockReadFile.mockResolvedValue(JSON.stringify(mockConfig));
+
+      const config = await readAuthConfig();
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('should throw helpful error when file does not exist', async () => {
+      const mockReadFile = vi.mocked(fs.readFile);
+      mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+
+      await expect(readAuthConfig()).rejects.toThrow(/No stored credentials/);
+    });
+  });
+
+  describe('deleteAuthConfig', () => {
+    it('should delete credentials file', async () => {
+      const mockUnlink = vi.fn().mockResolvedValue(undefined);
+      vi.doMock('node:fs/promises', () => ({
+        unlink: mockUnlink,
+      }));
+
+      await deleteAuthConfig();
+
+      // Should not throw
+    });
+
+    it('should not throw if file does not exist', async () => {
+      const mockUnlink = vi.fn().mockRejectedValue({ code: 'ENOENT' });
+      vi.doMock('node:fs/promises', () => ({
+        unlink: mockUnlink,
+      }));
+
+      await expect(deleteAuthConfig()).resolves.not.toThrow();
+    });
+  });
+});
+
+describe('Output Formatter Utilities', () => {
+  beforeEach(() => {
+    // Spy on console.log
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  it('should format JSON output', () => {
+    const data = { name: 'test', value: 123 };
+    formatOutput(data, 'json');
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('"name": "test"')
+    );
+  });
+
+  it('should format YAML output', () => {
+    const data = { name: 'test', value: 123 };
+    formatOutput(data, 'yaml');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('should format table output for arrays', () => {
+    const data = [
+      { name: 'item1', value: 1 },
+      { name: 'item2', value: 2 },
+    ];
+    formatOutput(data, 'table');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('should format table output for single object', () => {
+    const data = { name: 'test', value: 123 };
+    formatOutput(data, 'table');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('should handle empty arrays', () => {
+    const data: any[] = [];
+    formatOutput(data, 'table');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+});