@geekmidas/cli 0.53.0 → 1.0.0

package/src/deploy/__tests__/HostingerProvider.spec.ts

@@ -0,0 +1,347 @@
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from 'vitest';
+import { HostingerProvider } from '../dns/HostingerProvider';
+
+/**
+ * HostingerProvider Tests
+ *
+ * Uses MSW to mock the Hostinger DNS API.
+ * API Base: https://developers.hostinger.com
+ */
+describe('HostingerProvider', () => {
+	const HOSTINGER_API_BASE = 'https://developers.hostinger.com';
+	const TEST_DOMAIN = 'example.com';
+	const TEST_TOKEN = 'test-hostinger-token';
+
+	// Track current mock records for realistic API simulation
+	let mockRecords: Array<{
+		name: string;
+		type: string;
+		ttl: number;
+		records: Array<{ content: string }>;
+	}> = [];
+
+	// MSW server setup
+	const server = setupServer(
+		// GET /api/dns/v1/zones/{domain} - Get DNS records
+		http.get(
+			`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`,
+			({ request }) => {
+				// Check authorization
+				const authHeader = request.headers.get('Authorization');
+				if (authHeader !== `Bearer ${TEST_TOKEN}`) {
+					return HttpResponse.json(
+						{ message: 'Unauthorized' },
+						{ status: 401 },
+					);
+				}
+
+				return HttpResponse.json({ data: mockRecords });
+			},
+		),
+
+		// PUT /api/dns/v1/zones/{domain} - Upsert DNS records
+		http.put(
+			`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`,
+			async ({ request }) => {
+				// Check authorization
+				const authHeader = request.headers.get('Authorization');
+				if (authHeader !== `Bearer ${TEST_TOKEN}`) {
+					return HttpResponse.json(
+						{ message: 'Unauthorized' },
+						{ status: 401 },
+					);
+				}
+
+				const body = (await request.json()) as {
+					overwrite?: boolean;
+					zone: Array<{
+						name: string;
+						type: string;
+						ttl: number;
+						records: Array<{ content: string }>;
+					}>;
+				};
+
+				// Simulate upsert behavior
+				for (const record of body.zone) {
+					const existingIndex = mockRecords.findIndex(
+						(r) => r.name === record.name && r.type === record.type,
+					);
+					if (existingIndex >= 0) {
+						mockRecords[existingIndex] = record;
+					} else {
+						mockRecords.push(record);
+					}
+				}
+
+				return new HttpResponse(null, { status: 204 });
+			},
+		),
+	);
+
+	beforeAll(() => {
+		// Set the token via environment variable
+		process.env.HOSTINGER_API_TOKEN = TEST_TOKEN;
+		server.listen({ onUnhandledRequest: 'error' });
+	});
+
+	beforeEach(() => {
+		// Reset mock records before each test
+		mockRecords = [];
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	afterAll(() => {
+		delete process.env.HOSTINGER_API_TOKEN;
+		server.close();
+	});
+
+	describe('name', () => {
+		it('should have name "hostinger"', () => {
+			const provider = new HostingerProvider();
+			expect(provider.name).toBe('hostinger');
+		});
+	});
+
+	describe('getRecords', () => {
+		it('should throw error when token is invalid', async () => {
+			// Use an invalid token
+			const savedToken = process.env.HOSTINGER_API_TOKEN;
+			process.env.HOSTINGER_API_TOKEN = 'invalid-token';
+
+			try {
+				const provider = new HostingerProvider();
+				await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow(
+					'Hostinger API error',
+				);
+			} finally {
+				// Restore the token
+				process.env.HOSTINGER_API_TOKEN = savedToken;
+			}
+		});
+
+		it('should return empty array when no records exist', async () => {
+			const provider = new HostingerProvider();
+			const records = await provider.getRecords(TEST_DOMAIN);
+
+			expect(records).toEqual([]);
+		});
+
+		it('should return records from API', async () => {
+			// Set up mock records
+			mockRecords = [
+				{
+					name: 'api',
+					type: 'A',
+					ttl: 300,
+					records: [{ content: '1.2.3.4' }],
+				},
+				{
+					name: 'www',
+					type: 'CNAME',
+					ttl: 300,
+					records: [{ content: 'example.com' }],
+				},
+			];
+
+			const provider = new HostingerProvider();
+			const records = await provider.getRecords(TEST_DOMAIN);
+
+			expect(records).toHaveLength(2);
+			expect(records[0]).toEqual({
+				name: 'api',
+				type: 'A',
+				ttl: 300,
+				values: ['1.2.3.4'],
+			});
+			expect(records[1]).toEqual({
+				name: 'www',
+				type: 'CNAME',
+				ttl: 300,
+				values: ['example.com'],
+			});
+		});
+
+		it('should handle records with multiple values', async () => {
+			mockRecords = [
+				{
+					name: 'mail',
+					type: 'MX',
+					ttl: 3600,
+					records: [
+						{ content: '10 mail1.example.com' },
+						{ content: '20 mail2.example.com' },
+					],
+				},
+			];
+
+			const provider = new HostingerProvider();
+			const records = await provider.getRecords(TEST_DOMAIN);
+
+			expect(records).toHaveLength(1);
+			expect(records[0]?.values).toEqual([
+				'10 mail1.example.com',
+				'20 mail2.example.com',
+			]);
+		});
+
+		it('should cache API client after first call', async () => {
+			const provider = new HostingerProvider();
+
+			// Make two calls
+			await provider.getRecords(TEST_DOMAIN);
+			await provider.getRecords(TEST_DOMAIN);
+
+			// Both should succeed (API client is reused internally)
+			// If caching wasn't working, we'd see issues with token retrieval
+			expect(true).toBe(true);
+		});
+	});
+
+	describe('upsertRecords', () => {
+		it('should create new records', async () => {
+			const provider = new HostingerProvider();
+			const results = await provider.upsertRecords(TEST_DOMAIN, [
+				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
+			]);
+
+			expect(results).toHaveLength(1);
+			expect(results[0]).toEqual({
+				record: { name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
+				created: true,
+				unchanged: false,
+			});
+
+			// Verify record was added to mock store
+			expect(mockRecords).toHaveLength(1);
+			expect(mockRecords[0]).toEqual({
+				name: 'api',
+				type: 'A',
+				ttl: 300,
+				records: [{ content: '1.2.3.4' }],
+			});
+		});
+
+		it('should mark unchanged when record exists with same value', async () => {
+			// Pre-populate with existing record
+			mockRecords = [
+				{
+					name: 'api',
+					type: 'A',
+					ttl: 300,
+					records: [{ content: '1.2.3.4' }],
+				},
+			];
+
+			const provider = new HostingerProvider();
+			const results = await provider.upsertRecords(TEST_DOMAIN, [
+				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
+			]);
+
+			expect(results).toHaveLength(1);
+			expect(results[0]).toEqual({
+				record: { name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
+				created: false,
+				unchanged: true,
+			});
+		});
+
+		it('should update record when value changes', async () => {
+			// Pre-populate with existing record
+			mockRecords = [
+				{
+					name: 'api',
+					type: 'A',
+					ttl: 300,
+					records: [{ content: '1.2.3.4' }],
+				},
+			];
+
+			const provider = new HostingerProvider();
+			const results = await provider.upsertRecords(TEST_DOMAIN, [
+				{ name: 'api', type: 'A', ttl: 300, value: '5.6.7.8' },
+			]);
+
+			expect(results).toHaveLength(1);
+			expect(results[0]).toEqual({
+				record: { name: 'api', type: 'A', ttl: 300, value: '5.6.7.8' },
+				created: false,
+				unchanged: false,
+			});
+
+			// Verify record was updated in mock store
+			expect(mockRecords[0]?.records[0]?.content).toBe('5.6.7.8');
+		});
+
+		it('should handle multiple records with mixed states', async () => {
+			// Pre-populate with one existing record
+			mockRecords = [
+				{
+					name: 'api',
+					type: 'A',
+					ttl: 300,
+					records: [{ content: '1.2.3.4' }],
+				},
+			];
+
+			const provider = new HostingerProvider();
+			const results = await provider.upsertRecords(TEST_DOMAIN, [
+				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' }, // Unchanged
+				{ name: 'www', type: 'A', ttl: 300, value: '1.2.3.4' }, // New
+			]);
+
+			expect(results).toHaveLength(2);
+			expect(results[0]?.unchanged).toBe(true);
+			expect(results[1]?.created).toBe(true);
+
+			// Verify both records exist in mock store
+			expect(mockRecords).toHaveLength(2);
+		});
+	});
+
+	describe('API error handling', () => {
+		it('should handle API errors gracefully', async () => {
+			// Override the handler to return an error
+			server.use(
+				http.get(`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`, () => {
+					return HttpResponse.json(
+						{ message: 'Domain not found' },
+						{ status: 404 },
+					);
+				}),
+			);
+
+			const provider = new HostingerProvider();
+
+			await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow(
+				'Hostinger API error',
+			);
+		});
+
+		it('should handle network errors', async () => {
+			// Override the handler to simulate network error
+			server.use(
+				http.get(`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`, () => {
+					return HttpResponse.error();
+				}),
+			);
+
+			const provider = new HostingerProvider();
+
+			await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow();
+		});
+	});
+});

package/src/deploy/__tests__/LocalStateProvider.spec.ts

@@ -0,0 +1,126 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { LocalStateProvider } from '../LocalStateProvider';
+import type { DokployStageState } from '../state';
+
+describe('LocalStateProvider', () => {
+	let testDir: string;
+	let provider: LocalStateProvider;
+
+	beforeEach(async () => {
+		testDir = join(tmpdir(), `gkm-local-state-test-${Date.now()}`);
+		await mkdir(testDir, { recursive: true });
+		provider = new LocalStateProvider(testDir);
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	describe('read', () => {
+		it('should return null when state file does not exist', async () => {
+			const state = await provider.read('nonexistent');
+			expect(state).toBeNull();
+		});
+
+		it('should read existing state file', async () => {
+			const stateData: DokployStageState = {
+				provider: 'dokploy',
+				stage: 'production',
+				environmentId: 'env_123',
+				applications: { api: 'app_123' },
+				services: { postgresId: 'pg_123' },
+				lastDeployedAt: '2024-01-01T00:00:00.000Z',
+			};
+
+			await mkdir(join(testDir, '.gkm'), { recursive: true });
+			await writeFile(
+				join(testDir, '.gkm', 'deploy-production.json'),
+				JSON.stringify(stateData),
+			);
+
+			const state = await provider.read('production');
+			expect(state).toEqual(stateData);
+		});
+
+		it('should return null for invalid JSON', async () => {
+			await mkdir(join(testDir, '.gkm'), { recursive: true });
+			await writeFile(
+				join(testDir, '.gkm', 'deploy-invalid.json'),
+				'not valid json',
+			);
+
+			const state = await provider.read('invalid');
+			expect(state).toBeNull();
+		});
+	});
+
+	describe('write', () => {
+		it('should create .gkm directory if not exists', async () => {
+			const state: DokployStageState = {
+				provider: 'dokploy',
+				stage: 'staging',
+				environmentId: 'env_456',
+				applications: {},
+				services: {},
+				lastDeployedAt: '2024-01-01T00:00:00.000Z',
+			};
+
+			await provider.write('staging', state);
+
+			const content = await readFile(
+				join(testDir, '.gkm', 'deploy-staging.json'),
+				'utf-8',
+			);
+			expect(JSON.parse(content).stage).toBe('staging');
+		});
+
+		it('should update lastDeployedAt timestamp', async () => {
+			const state: DokployStageState = {
+				provider: 'dokploy',
+				stage: 'staging',
+				environmentId: 'env_456',
+				applications: {},
+				services: {},
+				lastDeployedAt: '2024-01-01T00:00:00.000Z',
+			};
+
+			const originalTimestamp = state.lastDeployedAt;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			await provider.write('staging', state);
+
+			expect(state.lastDeployedAt).not.toBe(originalTimestamp);
+		});
+
+		it('should preserve state data', async () => {
+			const state: DokployStageState = {
+				provider: 'dokploy',
+				stage: 'production',
+				environmentId: 'env_123',
+				applications: { api: 'app_123', web: 'app_456' },
+				services: { postgresId: 'pg_123', redisId: 'redis_123' },
+				appCredentials: { api: { dbUser: 'api', dbPassword: 'secret' } },
+				lastDeployedAt: '2024-01-01T00:00:00.000Z',
+			};
+
+			await provider.write('production', state);
+
+			const content = await readFile(
+				join(testDir, '.gkm', 'deploy-production.json'),
+				'utf-8',
+			);
+			const parsed = JSON.parse(content);
+
+			expect(parsed.applications).toEqual({ api: 'app_123', web: 'app_456' });
+			expect(parsed.services).toEqual({
+				postgresId: 'pg_123',
+				redisId: 'redis_123',
+			});
+			expect(parsed.appCredentials).toEqual({
+				api: { dbUser: 'api', dbPassword: 'secret' },
+			});
+		});
+	});
+});