matterbridge-lg-thinq-plugin 0.1.0

package/src/tests/cli/commands/login.test.ts

@@ -0,0 +1,240 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+let mockCoordinator: any;
+
+vi.mock('../../../services/authentication/AccountAuthStrategy.js', () => ({
+	AccountAuthStrategy: vi.fn(),
+}));
+
+vi.mock('../../../services/authentication/TokenAuthStrategy.js', () => ({
+	TokenAuthStrategy: vi.fn(),
+}));
+
+vi.mock('../../../services/authentication/AuthenticationCoordinator.js', () => ({
+	AuthenticationCoordinator: vi.fn(function () {
+		if (!mockCoordinator) {
+			mockCoordinator = { authenticate: vi.fn() };
+		}
+		return mockCoordinator;
+	}),
+}));
+
+vi.mock('../../../services/thinq/thinqApiClient.js', () => ({
+	ThinqApiClient: vi.fn(),
+}));
+
+vi.mock('../../../services/thinq/session.js', () => ({
+	ThinqSession: vi.fn(),
+}));
+
+vi.mock('../../../cli/session.js', () => ({
+	saveSession: vi.fn(),
+}));
+
+vi.mock('../../../cli/utils.js', () => ({
+	maskSecret: vi.fn((secret: string) => '*'.repeat(secret?.length || 0)),
+	parseArgs: vi.fn(),
+	prompt: vi.fn(),
+}));
+
+import { cmdLogin } from '../../../cli/commands/login.js';
+import { saveSession } from '../../../cli/session.js';
+import { maskSecret, prompt } from '../../../cli/utils.js';
+import { createMockLogger } from '../../helpers/testUtils.js';
+
+describe('cmdLogin', () => {
+	let mockLogger: any;
+	let consoleLogSpy: any;
+	let consoleErrorSpy: any;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockLogger = createMockLogger();
+		mockCoordinator = {
+			authenticate: vi.fn(),
+		};
+		consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+		consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+		vi.mocked(prompt).mockResolvedValue('mocked_answer');
+		vi.mocked(maskSecret).mockImplementation((secret?: string) => '*'.repeat(secret?.length || 0));
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		consoleLogSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+	});
+
+	it('should prompt for refresh token when type is "token"', async () => {
+		// Arrange
+		vi.mocked(prompt).mockResolvedValueOnce('refresh_token_value');
+		mockCoordinator.authenticate.mockResolvedValue(undefined);
+
+		// Act
+		await cmdLogin('token', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(prompt).toHaveBeenCalledWith('Refresh token: ');
+	});
+
+	it('should prompt for username and password when type is "account"', async () => {
+		// Arrange
+		vi.mocked(prompt).mockResolvedValueOnce('user@example.com').mockResolvedValueOnce('password123');
+		mockCoordinator.authenticate.mockResolvedValue(undefined);
+
+		// Act
+		await cmdLogin('account', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(prompt).toHaveBeenNthCalledWith(1, 'Username (email): ');
+		expect(prompt).toHaveBeenNthCalledWith(2, 'Password: ');
+	});
+
+	it('should error when authentication returns undefined', async () => {
+		// Arrange
+		vi.mocked(prompt).mockResolvedValue('answer');
+		mockCoordinator.authenticate.mockResolvedValue(undefined);
+
+		// Act
+		await cmdLogin('account', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(consoleErrorSpy).toHaveBeenCalledWith(
+			'Login did not complete: no session data was returned (a manual process may be required).',
+		);
+		expect(saveSession).not.toHaveBeenCalled();
+	});
+
+	it('should save session when authentication succeeds', async () => {
+		// Arrange
+		const mockUserData = {
+			accessToken: 'access_token_123',
+			refreshToken: 'refresh_token_456',
+			expiresAtEpochSeconds: 1609459200,
+			country: 'US',
+			language: 'en-US',
+		};
+		vi.mocked(prompt).mockResolvedValue('answer');
+		mockCoordinator.authenticate.mockResolvedValue(mockUserData);
+
+		// Act
+		await cmdLogin('account', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(saveSession).toHaveBeenCalledWith({
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: mockUserData,
+		});
+	});
+
+	it('should print success message', async () => {
+		// Arrange
+		const mockUserData = {
+			accessToken: 'token',
+			refreshToken: 'refresh',
+			expiresAtEpochSeconds: 1609459200,
+			country: 'US',
+			language: 'en-US',
+		};
+		vi.mocked(prompt).mockResolvedValue('answer');
+		mockCoordinator.authenticate.mockResolvedValue(mockUserData);
+
+		// Act
+		await cmdLogin('account', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith('Login successful. Session saved to .cli-session.json');
+		expect(consoleLogSpy).toHaveBeenCalledWith('Session Summary:');
+	});
+
+	it('should call maskSecret for tokens', async () => {
+		// Arrange
+		const mockUserData = {
+			accessToken: 'access_token_value',
+			refreshToken: 'refresh_token_value',
+			expiresAtEpochSeconds: 1609459200,
+			country: 'US',
+			language: 'en-US',
+		};
+		vi.mocked(prompt).mockResolvedValue('answer');
+		mockCoordinator.authenticate.mockResolvedValue(mockUserData);
+
+		// Act
+		await cmdLogin('token', 'US', 'en-US', mockLogger);
+
+		// Assert
+		expect(maskSecret).toHaveBeenCalledWith('access_token_value');
+		expect(maskSecret).toHaveBeenCalledWith('refresh_token_value');
+	});
+
+	it('should print formatted expiration date', async () => {
+		// Arrange
+		const mockUserData = {
+			accessToken: 'token',
+			refreshToken: 'refresh',
+			expiresAtEpochSeconds: 1609459200,
+			country: 'US',
+			language: 'en-US',
+		};
+		vi.mocked(prompt).mockResolvedValue('answer');
+		mockCoordinator.authenticate.mockResolvedValue(mockUserData);
+
+		// Act
+		await cmdLogin('account', 'US', 'en-US', mockLogger);
+
+		// Assert
+		const expectedDate = new Date(1609459200 * 1000).toISOString();
+		expect(consoleLogSpy).toHaveBeenCalledWith(`  Expires At: ${expectedDate}`);
+	});
+
+	it('should build auth context for token type', async () => {
+		// Arrange
+		vi.mocked(prompt).mockResolvedValueOnce('my_refresh_token');
+		mockCoordinator.authenticate.mockResolvedValue({
+			accessToken: 'token',
+			refreshToken: 'refresh',
+			expiresAtEpochSeconds: 123,
+			country: 'US',
+			language: 'en-US',
+		});
+
+		// Act
+		await cmdLogin('token', 'KR', 'ko-KR', mockLogger);
+
+		// Assert
+		const callArgs = mockCoordinator.authenticate.mock.calls[0];
+		expect(callArgs[0]).toBe('token');
+		expect(callArgs[1]).toEqual({
+			refreshToken: 'my_refresh_token',
+			country: 'KR',
+			language: 'ko-KR',
+		});
+	});
+
+	it('should build auth context for account type', async () => {
+		// Arrange
+		vi.mocked(prompt).mockResolvedValueOnce('user@email.com').mockResolvedValueOnce('pass123');
+		mockCoordinator.authenticate.mockResolvedValue({
+			accessToken: 'token',
+			refreshToken: 'refresh',
+			expiresAtEpochSeconds: 123,
+			country: 'US',
+			language: 'en-US',
+		});
+
+		// Act
+		await cmdLogin('account', 'KR', 'ko-KR', mockLogger);
+
+		// Assert
+		const callArgs = mockCoordinator.authenticate.mock.calls[0];
+		expect(callArgs[0]).toBe('account');
+		expect(callArgs[1]).toEqual({
+			username: 'user@email.com',
+			password: 'pass123',
+			country: 'KR',
+			language: 'ko-KR',
+		});
+	});
+});

package/src/tests/cli/help.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+
+import { HELP_TEXT } from '../../cli/help.js';
+
+describe('HELP_TEXT', () => {
+	it('should be a non-empty string', () => {
+		expect(HELP_TEXT).toBeDefined();
+		expect(typeof HELP_TEXT).toBe('string');
+		expect(HELP_TEXT.length).toBeGreaterThan(0);
+	});
+
+	it('should contain the "Usage:" section header', () => {
+		expect(HELP_TEXT).toContain('Usage:');
+	});
+
+	it('should contain the "Options:" section header', () => {
+		expect(HELP_TEXT).toContain('Options:');
+	});
+
+	it('should contain the "Commands:" section header', () => {
+		expect(HELP_TEXT).toContain('Commands:');
+	});
+
+	it('should contain the "Examples:" section header', () => {
+		expect(HELP_TEXT).toContain('Examples:');
+	});
+
+	it('should contain all three command names', () => {
+		expect(HELP_TEXT).toContain('login');
+		expect(HELP_TEXT).toContain('devices');
+		expect(HELP_TEXT).toContain('help');
+	});
+
+	it('should contain all option flags', () => {
+		expect(HELP_TEXT).toContain('--type');
+		expect(HELP_TEXT).toContain('--country');
+		expect(HELP_TEXT).toContain('--language');
+		expect(HELP_TEXT).toContain('--help');
+		expect(HELP_TEXT).toContain('--debug');
+	});
+
+	it('should contain descriptions for commands', () => {
+		expect(HELP_TEXT).toContain('Authenticate with LG ThinQ');
+		expect(HELP_TEXT).toContain('List all discovered ThinQ devices');
+	});
+});

package/src/tests/cli/main.test.ts

@@ -0,0 +1,214 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../../cli/commands/devices.js');
+vi.mock('../../cli/commands/login.js');
+vi.mock('../../cli/help.js');
+vi.mock('../../cli/session.js');
+vi.mock('../../cli/utils.js');
+
+import { cmdDevices } from '../../cli/commands/devices.js';
+import { cmdLogin } from '../../cli/commands/login.js';
+import { HELP_TEXT } from '../../cli/help.js';
+import { main } from '../../cli/main.js';
+import { loadSession } from '../../cli/session.js';
+import { parseArgs } from '../../cli/utils.js';
+
+describe('main', () => {
+	let consoleLogSpy: any;
+	let consoleErrorSpy: any;
+	let processExitSpy: any;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+		consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+		processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		consoleLogSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+		processExitSpy.mockRestore();
+	});
+
+	it('should print help and exit with 1 when no command is provided', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: '' });
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith(HELP_TEXT);
+		expect(processExitSpy).toHaveBeenCalledWith(1);
+	});
+
+	it('should print help and exit with 0 when command is "help"', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'help' });
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith(HELP_TEXT);
+		expect(processExitSpy).toHaveBeenCalledWith(0);
+	});
+
+	it('should print help and exit with 0 when --help flag is set', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ help: 'true' });
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleLogSpy).toHaveBeenCalledWith(HELP_TEXT);
+		expect(processExitSpy).toHaveBeenCalledWith(0);
+	});
+
+	it('should call cmdLogin when command is "login"', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({
+			command: 'login',
+			type: 'account',
+			country: 'US',
+			language: 'en-US',
+		});
+		vi.mocked(cmdLogin).mockResolvedValue(undefined);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(cmdLogin).toHaveBeenCalled();
+	});
+
+	it('should call cmdLogin with default values when flags are omitted', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'login' });
+		vi.mocked(cmdLogin).mockResolvedValue(undefined);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(cmdLogin).toHaveBeenCalled();
+	});
+
+	it('should call cmdDevices when command is "devices" and session exists', async () => {
+		// Arrange
+		const mockSession = {
+			loginType: 'account' as const,
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		vi.mocked(parseArgs).mockReturnValue({ command: 'devices' });
+		vi.mocked(loadSession).mockReturnValue(mockSession);
+		vi.mocked(cmdDevices).mockResolvedValue(undefined);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(cmdDevices).toHaveBeenCalledWith(mockSession, expect.any(Object), undefined, undefined);
+	});
+
+	it('should call cmdDevices with dump-snapshot flag when --dump-snapshot is provided', async () => {
+		// Arrange
+		const mockSession = {
+			loginType: 'account' as const,
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token',
+				refreshToken: 'refresh',
+				expiresAtEpochSeconds: 123,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		vi.mocked(parseArgs).mockReturnValue({ command: 'devices', 'dump-snapshot': 'washer-123' });
+		vi.mocked(loadSession).mockReturnValue(mockSession);
+		vi.mocked(cmdDevices).mockResolvedValue(undefined);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(cmdDevices).toHaveBeenCalledWith(mockSession, expect.any(Object), 'washer-123', undefined);
+	});
+
+	it('should error when command is "devices" but session does not exist', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'devices' });
+		vi.mocked(loadSession).mockReturnValue(null);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleErrorSpy).toHaveBeenCalledWith('No session found. Run `--command login` first.');
+		expect(cmdDevices).not.toHaveBeenCalled();
+	});
+
+	it('should error and exit when command is unknown', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'unknown' });
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown command: unknown'));
+		expect(processExitSpy).toHaveBeenCalledWith(1);
+	});
+
+	it('should catch and handle Error thrown from cmdLogin', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'login' });
+		vi.mocked(cmdLogin).mockRejectedValue(new Error('Login failed'));
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleErrorSpy).toHaveBeenCalledWith('Error:', 'Login failed');
+		expect(processExitSpy).toHaveBeenCalledWith(1);
+	});
+
+	it('should handle non-Error thrown value', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'login' });
+		vi.mocked(cmdLogin).mockRejectedValue('String error');
+
+		// Act
+		await main();
+
+		// Assert
+		expect(consoleErrorSpy).toHaveBeenCalledWith('Error:', 'String error');
+		expect(processExitSpy).toHaveBeenCalledWith(1);
+	});
+
+	it('should return without further processing after cmdLogin succeeds', async () => {
+		// Arrange
+		vi.mocked(parseArgs).mockReturnValue({ command: 'login' });
+		vi.mocked(cmdLogin).mockResolvedValue(undefined);
+
+		// Act
+		await main();
+
+		// Assert
+		expect(cmdLogin).toHaveBeenCalled();
+		expect(processExitSpy).not.toHaveBeenCalled();
+		expect(consoleErrorSpy).not.toHaveBeenCalled();
+	});
+});

package/src/tests/cli/session.test.ts

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock fs before importing saveSession
+vi.mock('node:fs');
+
+import fs from 'node:fs';
+
+import { loadSession, saveSession } from '../../cli/session.js';
+import type { CliSession } from '../../cli/types.js';
+
+describe('saveSession', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should write session to .cli-session.json with correct structure', () => {
+		// Arrange
+		const mockSession: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'a',
+				refreshToken: 'b',
+				expiresAtEpochSeconds: 0,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+
+		// Act
+		saveSession(mockSession);
+
+		// Assert
+		expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+		const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+		expect(callArgs[0]).toBe('.cli-session.json');
+
+		// Verify the second argument is valid JSON that matches the session
+		const writtenJson = callArgs[1] as string;
+		const parsedSession = JSON.parse(writtenJson);
+		expect(parsedSession).toEqual(mockSession);
+	});
+
+	it('should write session with token login type', () => {
+		// Arrange
+		const mockSession: CliSession = {
+			loginType: 'token',
+			country: 'KR',
+			language: 'ko-KR',
+			userData: {
+				accessToken: 'token123',
+				refreshToken: 'refresh456',
+				expiresAtEpochSeconds: 1234567890,
+				country: 'KR',
+				language: 'ko-KR',
+			},
+		};
+
+		// Act
+		saveSession(mockSession);
+
+		// Assert
+		expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+		const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+		const writtenJson = callArgs[1] as string;
+		const parsedSession = JSON.parse(writtenJson);
+		expect(parsedSession.loginType).toBe('token');
+		expect(parsedSession.country).toBe('KR');
+		expect(parsedSession.language).toBe('ko-KR');
+	});
+
+	it('should format JSON with proper indentation', () => {
+		// Arrange
+		const mockSession: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'a',
+				refreshToken: 'b',
+				expiresAtEpochSeconds: 0,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+
+		// Act
+		saveSession(mockSession);
+
+		// Assert
+		const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+		const writtenJson = callArgs[1] as string;
+
+		// Check that the JSON is formatted with 2-space indentation
+		expect(writtenJson).toContain('\n');
+		expect(writtenJson).toContain('  ');
+		// Verify it's valid JSON
+		const parsed = JSON.parse(writtenJson);
+		expect(parsed).toBeDefined();
+	});
+
+	it('should write all session fields correctly', () => {
+		// Arrange
+		const mockSession: CliSession = {
+			loginType: 'account',
+			country: 'GB',
+			language: 'en-GB',
+			userData: {
+				accessToken: 'access123',
+				refreshToken: 'refresh789',
+				expiresAtEpochSeconds: 1609459200,
+				country: 'GB',
+				language: 'en-GB',
+			},
+		};
+
+		// Act
+		saveSession(mockSession);
+
+		// Assert
+		const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+		const writtenJson = callArgs[1] as string;
+		const parsedSession = JSON.parse(writtenJson);
+
+		expect(parsedSession.loginType).toBe('account');
+		expect(parsedSession.country).toBe('GB');
+		expect(parsedSession.language).toBe('en-GB');
+		expect(parsedSession.userData.accessToken).toBe('access123');
+		expect(parsedSession.userData.refreshToken).toBe('refresh789');
+		expect(parsedSession.userData.expiresAtEpochSeconds).toBe(1609459200);
+		expect(parsedSession.userData.country).toBe('GB');
+		expect(parsedSession.userData.language).toBe('en-GB');
+	});
+});
+
+describe('loadSession', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should return parsed CliSession when file exists and contains valid JSON', () => {
+		// Arrange
+		const mockSession: CliSession = {
+			loginType: 'account',
+			country: 'US',
+			language: 'en-US',
+			userData: {
+				accessToken: 'token123',
+				refreshToken: 'refresh456',
+				expiresAtEpochSeconds: 1609459200,
+				country: 'US',
+				language: 'en-US',
+			},
+		};
+		vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockSession));
+
+		// Act
+		const result = loadSession();
+
+		// Assert
+		expect(result).toEqual(mockSession);
+		expect(fs.readFileSync).toHaveBeenCalledWith('.cli-session.json', 'utf-8');
+	});
+
+	it('should return null when file does not exist', () => {
+		// Arrange
+		vi.mocked(fs.readFileSync).mockImplementation(() => {
+			const err = new Error('ENOENT: no such file or directory');
+			throw err;
+		});
+
+		// Act
+		const result = loadSession();
+
+		// Assert
+		expect(result).toBeNull();
+	});
+
+	it('should return null when file contains invalid JSON', () => {
+		// Arrange
+		vi.mocked(fs.readFileSync).mockReturnValue('{ invalid json }');
+
+		// Act
+		const result = loadSession();
+
+		// Assert
+		expect(result).toBeNull();
+	});
+});