Gronod
5342170ced
Some checks failed
- Convert all client test files from CommonJS require() to ES module import syntax - Convert downloadClients.test.js and integration/downloadClients.test.js to ES modules - Fix qbittorrent.test.js to use getActiveDownloads() instead of getTorrents() - All test files now use proper Vitest-compatible ES module syntax - Resolves Vitest import errors and QBittorrentClient method call errors
294 lines
9.8 KiB
JavaScript
294 lines
9.8 KiB
JavaScript
// Copyright (c) 2026 Gordon Bolton. MIT License.
|
|
import {
|
|
initializeClients,
|
|
getAllDownloads,
|
|
getDownloadsByClientType,
|
|
testAllConnections
|
|
} from '../../server/utils/downloadClients.js';
|
|
import { vi } from 'vitest';
|
|
|
|
// Mock environment variables for testing
|
|
process.env.SABNZBD_INSTANCES = JSON.stringify([
|
|
{
|
|
id: 'test-sab',
|
|
name: 'Test SABnzbd',
|
|
url: 'http://localhost:8080',
|
|
apiKey: 'test-api-key'
|
|
}
|
|
]);
|
|
|
|
process.env.QBITTORRENT_INSTANCES = JSON.stringify([
|
|
{
|
|
id: 'test-qb',
|
|
name: 'Test qBittorrent',
|
|
url: 'http://localhost:8080',
|
|
username: 'admin',
|
|
password: 'adminadmin'
|
|
}
|
|
]);
|
|
|
|
process.env.TRANSMISSION_INSTANCES = JSON.stringify([
|
|
{
|
|
id: 'test-trans',
|
|
name: 'Test Transmission',
|
|
url: 'http://localhost:9091',
|
|
username: 'transmission',
|
|
password: 'transmission'
|
|
}
|
|
]);
|
|
|
|
process.env.RTORRENT_INSTANCES = JSON.stringify([
|
|
{
|
|
id: 'test-rtorrent',
|
|
name: 'Test rTorrent',
|
|
url: 'http://localhost:8080/RPC2',
|
|
username: 'rtorrent',
|
|
password: 'rtorrent'
|
|
}
|
|
]);
|
|
|
|
// Mock axios to prevent actual network calls
|
|
vi.mock('axios');
|
|
vi.mock('../../server/utils/logger', () => ({
|
|
logToFile: vi.fn()
|
|
}));
|
|
|
|
describe('Download Clients Integration Tests', () => {
|
|
describe('Client Initialization', () => {
|
|
it('should initialize all configured client types', async () => {
|
|
await initializeClients();
|
|
|
|
// The registry should have clients for all three types
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
|
|
// Should have keys for each client type (even if empty due to mocked failures)
|
|
expect(typeof downloadsByType).toBe('object');
|
|
});
|
|
|
|
it('should handle missing environment variables gracefully', async () => {
|
|
// Temporarily clear environment variables
|
|
const originalSab = process.env.SABNZBD_INSTANCES;
|
|
const originalQb = process.env.QBITTORRENT_INSTANCES;
|
|
const originalTrans = process.env.TRANSMISSION_INSTANCES;
|
|
|
|
delete process.env.SABNZBD_INSTANCES;
|
|
delete process.env.QBITTORRENT_INSTANCES;
|
|
delete process.env.TRANSMISSION_INSTANCES;
|
|
|
|
await initializeClients();
|
|
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
expect(Object.keys(downloadsByType)).toHaveLength(0);
|
|
|
|
// Restore environment variables
|
|
process.env.SABNZBD_INSTANCES = originalSab;
|
|
process.env.QBITTORRENT_INSTANCES = originalQb;
|
|
process.env.TRANSMISSION_INSTANCES = originalTrans;
|
|
});
|
|
});
|
|
|
|
describe('Download Aggregation', () => {
|
|
it('should aggregate downloads from multiple client types', async () => {
|
|
await initializeClients();
|
|
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
const allDownloads = await getAllDownloads();
|
|
|
|
// Should return downloads grouped by type
|
|
expect(typeof downloadsByType).toBe('object');
|
|
|
|
// Should return flattened array of all downloads
|
|
expect(Array.isArray(allDownloads)).toBe(true);
|
|
|
|
// All downloads should have required normalized fields
|
|
allDownloads.forEach(download => {
|
|
expect(download).toHaveProperty('id');
|
|
expect(download).toHaveProperty('title');
|
|
expect(download).toHaveProperty('type');
|
|
expect(download).toHaveProperty('client');
|
|
expect(download).toHaveProperty('instanceId');
|
|
expect(download).toHaveProperty('instanceName');
|
|
expect(download).toHaveProperty('status');
|
|
expect(download).toHaveProperty('progress');
|
|
expect(download).toHaveProperty('size');
|
|
expect(download).toHaveProperty('downloaded');
|
|
expect(download).toHaveProperty('speed');
|
|
expect(download).toHaveProperty('raw');
|
|
});
|
|
});
|
|
|
|
it('should maintain type consistency across clients', async () => {
|
|
await initializeClients();
|
|
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
|
|
// Check that each client type returns consistent data structure
|
|
Object.entries(downloadsByType).forEach(([clientType, downloads]) => {
|
|
if (downloads.length > 0) {
|
|
downloads.forEach(download => {
|
|
expect(download.client).toBe(clientType);
|
|
expect(download.type).toMatch(/^(usenet|torrent)$/);
|
|
expect(typeof download.progress).toBe('number');
|
|
expect(download.progress).toBeGreaterThanOrEqual(0);
|
|
expect(download.progress).toBeLessThanOrEqual(100);
|
|
expect(typeof download.size).toBe('number');
|
|
expect(typeof download.downloaded).toBe('number');
|
|
expect(typeof download.speed).toBe('number');
|
|
});
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Connection Testing', () => {
|
|
it('should test connections for all configured clients', async () => {
|
|
await initializeClients();
|
|
|
|
const results = await testAllConnections();
|
|
|
|
expect(Array.isArray(results)).toBe(true);
|
|
|
|
results.forEach(result => {
|
|
expect(result).toHaveProperty('instanceId');
|
|
expect(result).toHaveProperty('instanceName');
|
|
expect(result).toHaveProperty('clientType');
|
|
expect(result).toHaveProperty('success');
|
|
expect(typeof result.success).toBe('boolean');
|
|
|
|
if (!result.success) {
|
|
expect(result).toHaveProperty('error');
|
|
expect(typeof result.error).toBe('string');
|
|
}
|
|
});
|
|
});
|
|
|
|
it('should handle connection failures gracefully', async () => {
|
|
// This test verifies that connection failures don't crash the system
|
|
await initializeClients();
|
|
|
|
const results = await testAllConnections();
|
|
|
|
// Should still return results even if connections fail
|
|
expect(results.length).toBeGreaterThan(0);
|
|
|
|
// Failed connections should have error information
|
|
results.forEach(result => {
|
|
if (!result.success) {
|
|
expect(result.error).toBeTruthy();
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Error Handling and Resilience', () => {
|
|
it('should handle individual client failures without affecting others', async () => {
|
|
await initializeClients();
|
|
|
|
// Even if some clients fail, others should still work
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
const allDownloads = await getAllDownloads();
|
|
|
|
expect(typeof downloadsByType).toBe('object');
|
|
expect(Array.isArray(allDownloads)).toBe(true);
|
|
});
|
|
|
|
it('should handle malformed configuration gracefully', async () => {
|
|
// Test with malformed JSON
|
|
const originalSab = process.env.SABNZBD_INSTANCES;
|
|
process.env.SABNZBD_INSTANCES = 'invalid-json{';
|
|
|
|
// Should not throw an error
|
|
await expect(initializeClients()).resolves.not.toThrow();
|
|
|
|
// Restore
|
|
process.env.SABNZBD_INSTANCES = originalSab;
|
|
});
|
|
|
|
it('should handle network timeouts and errors', async () => {
|
|
await initializeClients();
|
|
|
|
// Mock network failures by setting up axios to reject
|
|
const axios = require('axios');
|
|
axios.get.mockRejectedValue(new Error('Network timeout'));
|
|
axios.post.mockRejectedValue(new Error('Network timeout'));
|
|
|
|
// Should handle errors gracefully and return empty results
|
|
const downloads = await getAllDownloads();
|
|
expect(Array.isArray(downloads)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Backward Compatibility', () => {
|
|
it('should maintain compatibility with existing cache structure', async () => {
|
|
await initializeClients();
|
|
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
|
|
// SABnzbd downloads should have raw data for legacy compatibility
|
|
if (downloadsByType.sabnzbd && downloadsByType.sabnzbd.length > 0) {
|
|
downloadsByType.sabnzbd.forEach(download => {
|
|
expect(download.raw).toBeTruthy();
|
|
expect(download.raw.source).toMatch(/^(queue|history)$/);
|
|
});
|
|
}
|
|
|
|
// qBittorrent downloads should have raw data for legacy compatibility
|
|
if (downloadsByType.qbittorrent && downloadsByType.qbittorrent.length > 0) {
|
|
downloadsByType.qbittorrent.forEach(download => {
|
|
expect(download.raw).toBeTruthy();
|
|
expect(download.raw.hash).toBeTruthy(); // qBittorrent specific field
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Performance and Scalability', () => {
|
|
it('should handle multiple instances of the same client type', async () => {
|
|
// Configure multiple instances
|
|
process.env.QBITTORRENT_INSTANCES = JSON.stringify([
|
|
{
|
|
id: 'test-qb-1',
|
|
name: 'Test qBittorrent 1',
|
|
url: 'http://localhost:8080',
|
|
username: 'admin',
|
|
password: 'adminadmin'
|
|
},
|
|
{
|
|
id: 'test-qb-2',
|
|
name: 'Test qBittorrent 2',
|
|
url: 'http://localhost:8081',
|
|
username: 'admin',
|
|
password: 'adminadmin'
|
|
}
|
|
]);
|
|
|
|
await initializeClients();
|
|
|
|
const downloadsByType = await getDownloadsByClientType();
|
|
|
|
// Should aggregate downloads from both instances
|
|
expect(Array.isArray(downloadsByType.qbittorrent)).toBe(true);
|
|
|
|
// Each download should have correct instance information
|
|
downloadsByType.qbittorrent.forEach(download => {
|
|
expect(download.instanceId).toMatch(/^(test-qb-1|test-qb-2)$/);
|
|
expect(download.instanceName).toMatch(/^(Test qBittorrent 1|Test qBittorrent 2)$/);
|
|
});
|
|
});
|
|
|
|
it('should execute client requests in parallel', async () => {
|
|
const startTime = Date.now();
|
|
|
|
await initializeClients();
|
|
await getAllDownloads();
|
|
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
|
|
// This is a rough check - in a real scenario with actual network calls,
|
|
// parallel execution should be significantly faster than sequential
|
|
expect(duration).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
});
|