rustfs-console/tests/utils/error-handler.test.ts

import { describe, expect, it } from 'vitest';
import { ConfigLoadError, handleConfigError, parseApiError } from '../../utils/error-handler';

describe('ConfigLoadError', () => {
  it('should create error with correct properties', () => {
    const error = new ConfigLoadError('Test message', 'INVALID_URL');

    expect(error.message).toBe('Test message');
    expect(error.code).toBe('INVALID_URL');
    expect(error.name).toBe('ConfigLoadError');
  });

  it('should default to UNKNOWN_ERROR code', () => {
    const error = new ConfigLoadError('Test message');
    expect(error.code).toBe('UNKNOWN_ERROR');
  });

  it('should store original error', () => {
    const originalError = new Error('Original error');
    const error = new ConfigLoadError('Test message', 'NETWORK_ERROR', originalError);

    expect(error.originalError).toBe(originalError);
  });

  it('should support all error codes', () => {
    const codes: Array<ConfigLoadError['code']> = ['INVALID_URL', 'STORAGE_ERROR', 'NETWORK_ERROR', 'UNKNOWN_ERROR'];

    codes.forEach(code => {
      const error = new ConfigLoadError('Test', code);
      expect(error.code).toBe(code);
    });
  });
});

describe('parseApiError', () => {
  it('should parse JSON error response', async () => {
    const response = new Response(JSON.stringify({ message: 'API Error' }), { status: 400, statusText: 'Bad Request' });

    const result = await parseApiError(response);
    expect(result).toBe('API Error');
  });

  it('should stringify JSON when no message property exists', async () => {
    const errorData = { error: 'Something went wrong', code: 500 };
    const response = new Response(JSON.stringify(errorData), { status: 500 });

    const result = await parseApiError(response);
    expect(result).toBe(JSON.stringify(errorData));
  });

  it('should parse XML error with Message tag', async () => {
    const xmlError = '<Error><Message>XML Error Message</Message></Error>';
    const response = new Response(xmlError, { status: 400 });

    const result = await parseApiError(response);
    expect(result).toBe('XML Error Message');
  });

  it('should parse XML error with Error tag', async () => {
    const xmlError = '<Response><Error>XML Error Content</Error></Response>';
    const response = new Response(xmlError, { status: 400 });

    const result = await parseApiError(response);
    expect(result).toBe('XML Error Content');
  });

  it('should return plain text when not JSON or XML', async () => {
    const response = new Response('Plain text error', { status: 400 });

    const result = await parseApiError(response);
    expect(result).toBe('Plain text error');
  });

  it('should return statusText when response body cannot be parsed', async () => {
    const response = new Response(null, {
      status: 500,
      statusText: 'Internal Server Error',
    });

    const result = await parseApiError(response);
    expect(result).toBe('Internal Server Error');
  });

  it('should handle empty response body', async () => {
    const response = new Response('', {
      status: 404,
      statusText: 'Not Found',
    });

    const result = await parseApiError(response);
    expect(result).toBe('Not Found');
  });

  it('should extract message from nested XML structure', async () => {
    const xmlError = `
      <?xml version="1.0"?>
      <Error>
        <Code>NoSuchBucket</Code>
        <Message>The specified bucket does not exist</Message>
      </Error>
    `;
    const response = new Response(xmlError, { status: 404 });

    const result = await parseApiError(response);
    expect(result).toBe('The specified bucket does not exist');
  });
});

describe('handleConfigError', () => {
  it('should return ConfigLoadError as-is', () => {
    const originalError = new ConfigLoadError('Original', 'INVALID_URL');
    const result = handleConfigError(originalError, 'test context');

    expect(result).toBe(originalError);
  });

  it('should detect invalid URL errors', () => {
    const error = new Error('Invalid URL: http://');
    const result = handleConfigError(error, 'config loading');

    expect(result).toBeInstanceOf(ConfigLoadError);
    expect(result.code).toBe('INVALID_URL');
    expect(result.message).toContain('Invalid URL');
    expect(result.message).toContain('config loading');
    expect(result.originalError).toBe(error);
  });

  it('should detect storage errors', () => {
    const error = new Error('localStorage is not available');
    const result = handleConfigError(error, 'save config');

    expect(result).toBeInstanceOf(ConfigLoadError);
    expect(result.code).toBe('STORAGE_ERROR');
    expect(result.message).toContain('Storage error');
    expect(result.message).toContain('save config');
  });

  it('should detect network errors', () => {
    const error = new Error('fetch failed due to network');
    const result = handleConfigError(error, 'fetch config');

    expect(result).toBeInstanceOf(ConfigLoadError);
    expect(result.code).toBe('NETWORK_ERROR');
    expect(result.message).toContain('Network error');
    expect(result.message).toContain('fetch config');
  });

  it('should handle unknown errors', () => {
    const error = new Error('Some random error');
    const result = handleConfigError(error, 'process');

    expect(result).toBeInstanceOf(ConfigLoadError);
    expect(result.code).toBe('UNKNOWN_ERROR');
    expect(result.message).toContain('Unknown error');
    expect(result.message).toContain('process');
  });

  it('should handle non-Error objects', () => {
    const error = 'String error message';
    const result = handleConfigError(error, 'operation');

    expect(result).toBeInstanceOf(ConfigLoadError);
    expect(result.code).toBe('UNKNOWN_ERROR');
    expect(result.message).toContain('String error message');
  });

  it('should handle null/undefined errors', () => {
    const result1 = handleConfigError(null, 'null test');
    const result2 = handleConfigError(undefined, 'undefined test');

    expect(result1).toBeInstanceOf(ConfigLoadError);
    expect(result1.code).toBe('UNKNOWN_ERROR');
    expect(result2).toBeInstanceOf(ConfigLoadError);
    expect(result2.code).toBe('UNKNOWN_ERROR');
  });

  it('should preserve context in error message', () => {
    const error = new Error('Test error');
    const context = 'loading user configuration';
    const result = handleConfigError(error, context);

    expect(result.message).toContain(context);
  });

  it('should detect storage error with "storage" keyword', () => {
    const error = new Error('Failed to access storage');
    const result = handleConfigError(error, 'test');

    expect(result.code).toBe('STORAGE_ERROR');
  });
});